暗影八度
暗影八度

spring+shiro+reids+ehcache实现session管理

前两天，在项目中遇到需要对session管理的 一个需求，查询了各种资料，也遇到了各种问题，不过，最后还是实现了需求，在此，也总结一下实现的过程，方便以后查阅。文中借鉴了很多其他文章内容，如有不当敬请谅解，一切以学习为主。

项目需求

  • 统计查看在线人数
  • 控制在线人数，管理员可下线某在线用户
  • 控制用户在线时长

  • 保证同一用户只能在同一客户端登录

    基于需求分析，考虑使用redis缓存session的方案：
    1.使用redis可方便的设置缓存的有限期，这样可控制用户的在线时长问题。用户登录，前端操作均会更新缓存数据。
    2.redis性能毋庸置疑，同时，redis的java api也能方便操作redis中的数据

项目依赖

<properties>
    
    <springside.version>4.2.3-GAspringside.version>
    <spring.version>4.0.5.RELEASEspring.version>
    <shiro.version>1.2.3shiro.version>
properties>

<dependency>
    <groupId>org.springsidegroupId>
    <artifactId>springside-coreartifactId>
    <version>${springside.version}version>
dependency>
<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-springartifactId>
    <version>${shiro.version}version>
dependency>
<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-ehcacheartifactId>
    <version>${shiro.version}version>
dependency>
<dependency>
    <groupId>org.springframework.sessiongroupId>
          <artifactId>spring-session-data-redisartifactId>
          <version>1.1.1.RELEASEversion>
          <type>pomtype>
dependency
<dependency>
    <groupId>org.crazycakegroupId>
    <artifactId>shiro-redisartifactId>
    <version>2.4.6version>
dependency>

web.xml配置filter，加载shiro和其他配置文件

    <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>
            classpath*:/applicationContext.xml,
            classpath*:/applicationContext-shiro.xml,
            classpath*:/applicationContext-session.xml
        param-value>
    context-param>

    <filter>  
        <filter-name>shiroFilterfilter-name>  
        <filter-class>org.springframework.web.filter.DelegatingFilterProxyfilter-class>
         <init-param>
              <param-name>targetFilterLifecycleparam-name>
              <param-value>trueparam-value>
          init-param>  
    filter>  
    <filter-mapping>  
        <filter-name>shiroFilterfilter-name>  
        <url-pattern>/*url-pattern> 
        <dispatcher>REQUESTdispatcher>
        <dispatcher>FORWARDdispatcher>
        <dispatcher>INCLUDEdispatcher>
        <dispatcher>ERRORdispatcher> 
    filter-mapping>

shiro配置文件applicationContext-shiro.xml


<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd"
    default-lazy-init="true">

    <description>Shiro安全配置description>
    
    <bean id="shiroRealm" class="com.sinosoft.bi.base.security.ShiroRealm">bean>

    
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="shiroRealm" />
        <property name="sessionManager" ref="sessionManager">property>
        <property name="cacheManager" ref="shiroEhcacheManager" />
    bean>
    
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <property name="loginUrl" value="/login" />
        <property name="successUrl" value="/" />
        <property name="unauthorizedUrl" value="/unauthorized" />
        <property name="filterChainDefinitions">
            <value>
                /login = authc
                /logout = logout
                /static/** = anon
                /admin/** = roles[admin]
                /** = user
            value>
        property>
    bean>

    
    <bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManagerConfigFile" value="classpath:ehcache/ehcache-shiro.xml" />
    bean>

    
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />

    
    

    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  
        <property name="sessionDAO" ref="sessionDao">property>  
        <property name="globalSessionTimeout" value="60000" />
        <property name="deleteInvalidSessions" value="true">property>
          
        <property name="sessionValidationSchedulerEnabled" value="true" />  
        <property name="sessionListeners" ref="myShiroSessionListener">property>
        
        
    bean>

     
    

    
    <bean id="sessionIdGenerator" class="org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator">bean>

    
    <bean id="myShiroSessionListener" class="com.sinosoft.bi.base.security.MyShiroSessionListener">bean>  

    <bean id="sessionDao" class="com.sinosoft.bi.base.security.SessionDao">  
        <property name="redisUtil" ref="redisUtil">property>
        <property name="sessionIdGenerator" ref="sessionIdGenerator">property>
    bean> 
beans>

applicationContext-session.xml


<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" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"
    default-lazy-init="true">

        
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" >    
            
        <property name="maxIdle" value="${redis.maxIdle}" />    
          
        <property name="maxTotal" value="${redis.maxTotal}" />  
            
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />    
          
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />   
          
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />   
          
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />   
            
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />    
          
        <property name="testWhileIdle" value="${redis.testWhileIdle}" />    
    bean >  


      
      

      
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">   
        <property name="poolConfig" ref="jedisPoolConfig">property>  

       

         <property name="hostName" value="127.0.0.1">property>   
          
        <property name="port" value="6379">property> 
          
       
          
        <property name="timeout" value="${redis.timeout}">property>   
    bean>    

      
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >    
        <property name="connectionFactory" ref="jedisConnectionFactory" />    
            
        <property name="keySerializer" >    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />    
        property>    
        <property name="valueSerializer" >    
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        property>    
        <property name="hashKeySerializer">    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
        property>    
        <property name="hashValueSerializer">    
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>    
        property>    
          
        <property name="enableTransactionSupport" value="true">property>  
    bean >      

beans>

redis配置文件redis.properties

redis.hostName=127.0.0.1 
redis.port=6379
#redis.password=123456
redis.timeout=10000  
redis.maxIdle=300  
redis.maxTotal=1000  
redis.maxWaitMillis=1000  
redis.minEvictableIdleTimeMillis=300000  
redis.numTestsPerEvictionRun=1024  
redis.timeBetweenEvictionRunsMillis=30000  
redis.testOnBorrow=true  
redis.testWhileIdle=true

ehcache-shiro.xml

<ehcache updateCheck="false" name="shiroCache">
   <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="false"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            />
ehcache>

User实体

public class User implements Serializable{
    private static final long serialVersionUID = 1L;
    private String userID;
    private String username;
    private String password;
    ...getter and setter
}

序列化和反序列化工具

public class SerializeUtils {

    /**
     * 序列化
     * 
     * @param object
     * @return
     * @throws Exception
     */
    public static byte[] serialize(Object object) throws Exception {
        if(object == null) return null;
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 反序列化
     * 
     * @param bytes
     * @return
     * @throws Exception
     */
    public static Object unSerialize(byte[] bytes) throws Exception {
        if(bytes == null) return null;
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
    }


    // 把session对象转化为byte保存到redis中  
    public static byte[] sessionToByte(Session session){  
        ByteArrayOutputStream bo = null; 
        byte[] bytes = null;
        ObjectOutput oo = null;
        try {
            bo = new ByteArrayOutputStream();  
            oo = new ObjectOutputStream(bo);  
            oo.writeObject(session);  
            bytes = bo.toByteArray();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally {
            try {
                if(null != oo){
                    oo.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if(null != bo){
                    bo.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bytes;  
    }  

    // 把byte还原为session  
    public static Session byteToSession(byte[] bytes){  
        ObjectInputStream in = null;
        Session session = null;  
        try {  
            in = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(bytes)));    
            session = (Session) in.readObject();  
        } catch (ClassNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  catch (Exception e) {
            e.printStackTrace();  
        }
        return session;  
    }  
}

redis工具类

/**
 * @author myj 
 *  基于spring和redis的redisTemplate工具类
 *  针对所有的hash 都是以h开头的方法 
 *  针对所有的Set  都是以s开头的方法 不含通用方法
 *  针对所有的List 都是以l开头的方法
 */

@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;

    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // =============================common============================
    /**
     * 指定缓存失效时间
     * 
     * @param key
     *            键
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * 
     * @param key
     *            键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * 
     * @param key
     *            键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    public List hmget(){
        List list = new ArrayList();
        List values = redisTemplate.boundHashOps(KEY).values();
        for (Object object : values) {
            list.add((Session) object);
        }
        return list;
    }


    public List keys(){
      Set values =  redisTemplate.keys("*");
      List list = new LinkedList();
      for (Object object : values) {
        list.add((String)object);
      }
      return list;
    }

    /**
     * 删除缓存
     * 
     * @param key
     *            可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

     /** 
     * 删除对应的value 
     *  
     * @param key 
     */  
    public void remove(final String key) {  
        if (exists(key)) {  
            redisTemplate.delete(key);  
        }  
    }

    /** 
     * 判断缓存中是否有对应的value 
     *  
     * @param key 
     * @return 
     */  
    public boolean exists(final String key) {  
        return redisTemplate.hasKey(key);  
    }  


    /** 
     * 批量删除对应的value 
     * @param keys 
     */  
    public void remove(final String... keys) {  
        for (String key : keys) {  
            remove(key);  
        }  
    }

    /** 
     * 批量删除key 
     *  
     * @param pattern 
     */  
    public void removePattern(final String pattern) {  
        Set keys = redisTemplate.keys(pattern);  
        if (keys.size() > 0)  
            redisTemplate.delete(keys);  
    }


    // ============================String=============================

    /**
     * 普通缓存放入并设置时间
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


     /** 
     * 读取缓存 
     *  
     * @param key 
     * @return 
     */  
    public Object get(final String key) {  
        Object result = null;  
        ValueOperations operations = redisTemplate.opsForValue();  
        result = operations.get(key);  
        return result;  
    }  

    /** 
     * 写入缓存 
     *  
     * @param key 
     * @param value 
     * @return 
     */  
    public boolean set(final String key, Object value) {  
        boolean result = false;  
        try {  
            ValueOperations operations = redisTemplate.opsForValue();  
            operations.set(key, value);  
            result = true;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  

    /** 
     * 写入缓存 
     *  
     * @param key 
     * @param value 
     * @return 
     */  
    public boolean set(final String key, Object value, Long expireTime) {  
        boolean result = false;  
        try {  
            ValueOperations operations = redisTemplate.opsForValue();  
            operations.set(key, value);  
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);  
            result = true;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  

    /**
     * 递增
     * 
     * @param key
     *            键
     * @param by
     *            要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * 
     * @param key
     *            键
     * @param by
     *            要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================
    /**
     * HashGet
     * 
     * @param key
     *            键 不能为null
     * @param item
     *            项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * 
     * @param key
     *            键
     * @return 对应的多个键值
     */
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * 
     * @param key
     *            键
     * @param map
     *            对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * 
     * @param key
     *            键
     * @param map
     *            对应多个键值
     * @param time
     *            时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param value
     *            值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param value
     *            值
     * @param time
     *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * 
     * @param key
     *            键 不能为null
     * @param item
     *            项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     * 
     * @param key
     *            键 不能为null
     * @param item
     *            项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param by
     *            要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param by
     *            要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * 
     * @param key
     *            键
     * @return
     */
    public Set sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * 
     * @param key
     *            键
     * @param values
     *            值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * 
     * @param key
     *            键
     * @param time
     *            时间(秒)
     * @param values
     *            值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * 
     * @param key
     *            键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * 
     * @param key
     *            键
     * @param values
     *            值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     * 
     * @param key
     *            键
     * @param start
     *            开始
     * @param end
     *            结束 0 到 -1代表所有值
     * @return
     */
    public List lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * 
     * @param key
     *            键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * 
     * @param key
     *            键
     * @param index
     *            索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, List value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, List value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * 
     * @param key
     *            键
     * @param index
     *            索引
     * @param value
     *            值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * 
     * @param key
     *            键
     * @param count
     *            移除多少个
     * @param value
     *            值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
} 
  
 
   
MyShiroSessionListener
 
  
 
  
public class MyShiroSessionListener implements SessionListener {  

    @Autowired RedisUtil redisUtil;

    @Override  
    public void onStart(Session session) {  
    }  

    @Override  
    public void onStop(Session session) {  
        redisUtil.remove(session.getId().toString());  
    }  

    @Override  
    public void onExpiration(Session session) {  
        redisUtil.remove(session.getId().toString());  
    }  

}  
 
  
 
   
SessionDao
 
  
 
  
@Component
public class SessionDao extends EnterpriseCacheSessionDAO {  

    private RedisUtil redisUtil; 

    public RedisUtil getRedisUtil(){
        return redisUtil;  
    }  

    public void setRedisUtil(RedisUtil redisUtil) {  
        this.redisUtil = redisUtil;  
    }  

    // 创建session，保存到数据库  
    @Override  
    protected Serializable doCreate(Session session) { 
        Serializable sessionId = super.doCreate(session);
        redisUtil.set(session.getId().toString(), SerializeUtils.sessionToByte(session),1*60*30L);
        return sessionId;  
    }  

    // 获取session  
    @Override  
    protected Session doReadSession(Serializable sessionId) {  
        // 先从缓存中获取session，如果没有再去数据库中获取  
       Session session = super.doReadSession(sessionId);
       if(session == null){
            Object object = null;
            byte[] bytes = null;
            if(redisUtil.exists(sessionId.toString())){
                object = redisUtil.get(sessionId.toString());
            }
            if(null != object){
                bytes = (byte[])object;
            }
            if(bytes != null && bytes.length > 0){  
                session = (Session) SerializeUtils.byteToSession(bytes);
            }  
        }  
        return session;
    }  

    // 更新session的最后一次访问时间  
    @Override  
    protected void doUpdate(Session session) {
        super.doUpdate(session);  
        redisUtil.set(session.getId().toString(), SerializeUtils.sessionToByte(session),1*60*30L);
    }

    @Override
    public Collection getActiveSessions() {
        List list = redisUtil.hmget();
        return list;
    }

    // 删除session  
    @Override
    public void doDelete(Session session) {  
        super.doDelete(session);  
        redisUtil.remove(session.getId().toString());  
    }  


}  
 
  
 
   
Usercontroller部分代码
 
  
 
  
    /**
     * 下线某在线用户
     * @return
     */
    @RequestMapping(value = "/offline")
    @ResponseBody
    public String offline(){
        String sessionid = getParams().getString("id");
        byte[] bytes = null;
        Session session =  null;
        try{
            if(redisUtil.exists(sessionid.toString())){
                bytes = (byte[]) redisUtil.get(sessionid.toString());
            }
            if(bytes != null && bytes.length > 0){  
                session = SerializeUtils.byteToSession(bytes);
                if(session !=  null){
                    sessionDao.delete(session);
                }
            }  
            return "success";
        }catch(Exception e){
            e.printStackTrace();
            return "error";
        }
    }

    /**
     * 获取在线人数
     * @param model
     * @return
     */
    @RequestMapping(value = "/getUserOnline")
    public String getUserOnline(Model model){
        Map onlineMap = null;
        Session session =  null;
        User user = null;
        byte[] bytes = null;
        try {
            List list = redisUtil.keys();
            if(list.size() >0){
                onlineMap = new LinkedHashMap();
                for (String key : list) {
                    if(redisUtil.exists(key.toString())){
                        bytes = (byte[]) redisUtil.get(key.toString());
                    }
                    if(bytes != null && bytes.length > 0){  
                        session = SerializeUtils.byteToSession(bytes);
                        if(session !=  null){
                            user = (User) session.getAttribute("currentUser");
                            if(user != null){
                                onlineMap.put(key, user);
                            }
                        }
                    }  
                }
            }
            model.addAttribute("onlineMap", onlineMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "base/user/online";
    }
 
  
 
   
spring容器启动监听，清楚redis中的缓存
 
  
 
  
/**
 * spring容器监听类
 * 容器重启时，清空redis缓存
 * @author mayi
 *
 */
@Component
public class MyContextRefreshedEvent implements ApplicationListener<ContextRefreshedEvent>{ 

    @Override  
    public void onApplicationEvent(ContextRefreshedEvent arg0) {  
        @SuppressWarnings("resource")
        JedisPool jedisPool = new JedisPool("127.0.0.1",6379);
        Jedis jedis = jedisPool.getResource();
        jedis.flushAll();
        jedis = null;
        jedisPool = null;
    }  

}  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(项目总结)

        

            

                
    
                    
  • MATLAB语言基础教程、 小项目1：简单的计算器、 小项目2：有页面的计算器、使用App Designer创建GUI计算器
                        azuredragonz
学习教程matlab开发语言
                        
    MATLABMATLAB语言基础教程1.MATLAB简介2.基本语法变量与赋值向量与矩阵矩阵运算数学函数控制流3.函数4.绘图案例：简单方程求解小项目1：简单的科学计算器功能代码项目说明小项目2：有页面的计算器使用AppDesigner创建GUI计算器主要步骤：完整代码（使用MATLAB编写）说明：如何运行：小项目总结MATLAB语言基础教程1.MATLAB简介MATLAB（矩阵实验室）是一种用于
    
                    
    • 
                    
  • 网上商城项目总结报告
                        WEB前端程序贵
前端
                        
    网上商城项目总结报告1：掌握的知识通过网上商城这个实战项目的开发，不仅了解到了一个项目的业务逻辑，而且掌握了实现相关业务功能的方法。通过这个实战项目，了解到了模块化开发项目的基础结构的搭建，以及项目文件的管理方式。通过这个实战项目，运用封装的接口api文档实现了客户端服务器之间的交互知识。通过封装的axios实例对象与方法，向服务器请求数据，然后渲染页面。通过运用localStorage本地储存的
    
                    
    • 
                    
  • 网上商城项目总结 续
                        猫只i
javaweb电子商城结构
                        
    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
    
                    
    • 
                    
  • 在 Spring Boot 项目中连接 IBM AS/400 数据库——详细案例教程
                        箬敏伊儿
数据库AS/400springboot数据库后端databasejava
                        
    文章目录1.添加`jt400`依赖2.下载`jt400`驱动包依赖下载手动下载下载地址：手动下载JAR的步骤：3.配置application.properties或application.yml（1）`application.properties`（2）`application.yml`4.数据源配置类（可选）5.创建`JDBC`访问层6.测试连接7.启动项目总结在SpringBoot项目中连接I
    
                    
    • 
                    
  • 被批一顿略有所感
                        浮生清逸

                        
    2021.4.7—阴周叁今天下午开了项目总结会，被批的体无完肤。当初为了独特点加入了特效，结果成了被批的点，所以小聪明不要有。一开始对此不怎么重视，导致被领导批审美不行什么的。当时真的无比尴尬，在几十人的会议上，没有给我留丝毫面子。以后的项目总结，就仿照其他同事了。在换页的时候慢一点，讲得更久一点，做好充足的准备。不会再犯第二次这种错误，既然指出了，我就去改正没什么大不了的。待自己变得足够优秀再潇
    
                    
    • 
                    
  • sap 项目总结
                        weixin_34405332
测试
                        
    SAP项目实施总结(转)项目还没结束，但很多经验已经可以开始总结了。对于这个项目，不完善的地方有很多，有我们自己的问题，也有用户的问题。从顾问自己的角度去看――我们可以做的更好。我们的SAP的项目包括以下的部分：项目前期调研SAP产品入门培训企业需求确定（蓝图）系统配置顾问内部测试用户操作培训用户单元测试用户集成测试项目最终培训系统交付与支持从我参与的情况来看，有几个部分是需要所有SAP实施顾问尤
    
                    
    • 
                    
  • 不费力不费脑，几个提升执行力的小技巧
                        我家的牛

                        
    文／我家的牛这些场景，你应该不陌生：1、早上计划了一堆待办事项，当晚没一件完成。2、领导很早就催你交项目总结报告，却总是等到前一天才开始动手。3、开始做事了，却管不住手脚，点开微信，刷刷微博，看看抖音……。没关系，你并不孤独，大家都一样。于是很多人感概，你干脆也不要做啥计划了？反正你也完不成，何必添堵呢？想一想，你每天真正用在执行上面的时间有多少，70%，50%？对于很多人来说，这个数字也许还会更
    
                    
    • 
                    
  • vue.js学习步骤
                        一雨方知深秋
vue.js
                        
    文章目录前言一、vue.js是什么？二、学习步骤1.基础知识2.进阶学习实战项目总结前言Vue.js从一个简单的实验性项目成长为一个功能强大、社区活跃的前端框架，其发展历程展示了它对前端开发的持续创新和改进。通过引入先进的功能和不断扩展的生态系统，Vue.js为开发者提供了一个高效、灵活的工具，满足了不同规模和复杂度应用的需求。一、vue.js是什么？Vue.js是一个灵活且高效的前端框架，旨在简
    
                    
    • 
                    
  • 当前主流的 ChatGPT 工具有哪些？
                        圣逸
人工智能专栏chatgpt
                        
    目录1.OpenAIChatGPT概述特色应用场景优缺点2.MicrosoftAzureOpenAIService概述特色应用场景优缺点3.GoogleBard概述特色应用场景优缺点4.ChatGPTbyAnthropic概述特色应用场景优缺点5.其他值得关注的工具5.1.HuggingFace5.2.FacebookAIResearch(FAIR)5.3.自然语言处理科研界的其他项目总结随着人工
    
                    
    • 
                    
  • vue项目总结
                        纯纯小白打码人
记录前端vueelementui
                        
    学习前端知识大概是三个月了吧，都是跟着b站的视频学的，学了基本三件套，然后学了vue框架，由于自己没有关于前端的项目经验，所以就在b站找了个项目跟着做，花了大概一个月时间做完了，也成功部署上线了。码云地址：https://gitee.com/chen-mu-pmf/test2022.git部署上线访问地址：电商后台管理系统其实做完之后有点陷入迷茫，没有收获的感觉，没有学习的踏实感，很多东西都只是走
    
                    
    • 
                    
  • 使用vue-cli自定义搭建项目步骤解析（Windows）
                        Leiccy
vuevue-cli3
                        
    使用vue-cli自定义搭建项目步骤解析（Windows）前言一、下载安装Node.js二、创建vue项目总结前言提示：在正式搭建vue脚手架（vue-cli）之前，必须要确保电脑已经安装好了Node.jsNode.js官网提示：以下内容为本篇文章正文，所演示案例仅供参考一、下载安装Node.js1、去Node.js官网下载安装包。2、安装步骤是在原有默认的选项下一直点击next即可，安装完成后去
    
                    
    • 
                    
  • 微服务学习 | Springboot整合Dubbo+Nacos实现RPC调用
                        牵着猫散步的鼠鼠
Java全栈微服务springbootdubbo学习后端
                        
    ️个人主页：鼠鼠我捏，要死了捏的主页️系列专栏：Golang全栈-专栏️个人学习笔记，若有缺误，欢迎评论区指正前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站AI学习网站。目录前言快速上手创建示例项目导入依赖编写配置添加启动类注解编写服务接口与服务实现类引入common项目新建common项目总结前言随着互联网技术的飞速发展，越来越多的企业和开发者开
    
                    
    • 
                    
  • 项目总结：毕业论文竣工感想
                        Cindy_Sze

                        
    一、趁早开始写毕业论文，因为你永远不知道答辩准备期还有多少别的屁事。二、别指望一气呵成。因为没有发个十篇八篇文，根本不具备一气呵成的思路连贯性。三、毕业论文其实就是公文写作，可以参考相关技巧。四、如果不是用得很熟练，《金字塔原理》帮不上什么忙。五、格式调整群需要的时间起码是连续工作两周的工作量。相信我，这个东西永无止境，不可能一劳永逸。六、参考文献最后存一个备用文件，储存对应的作者，年份，编号和观
    
                    
    • 
                    
  • 怎么在网上赚钱？这8种赚钱方法总有一种适合你。
                        优惠券高省

                        
    互联网创业者，每天分享互联网经验！最近有很多的网友留言，如何去赚钱？如何在网上赚钱？网上赚钱的方式有哪些？又有哪些正规可靠的兼职可以去做呢？为了让大家尽量少走弯路，少跳坑，今天我就把一些常见的赚钱项目总结一下，教大家如何在网上赚钱。一、高省APP(优惠劵导购平台)高省APP隶属杭州长孚科技有限公司，高省位于阿里投资的梦想小镇，高省创始团队来自前阿里、网易等高管，高省是一款可领取各大网购平台的隐藏优
    
                    
    • 
                    
  • 一场项目总结复盘会议纪实 2020.7.30
                        慧海无涯引力波

                        
    时光如水，引力波领导力提升特训营项目第二季度结束了，这期有来自七家公司21位学员参加，今天项目总结复盘会的议题有三项：1,学员分享：总结盘点领导力平衡轮成果及个人领导力发展计划阶段性成果呈现，收获和感悟，对于本项目的改进建议有哪些？2,人力资源部主管反馈：反馈学员行为改变情况，反馈项目进展评估，针对下一季度项目改进建议。3,项目总结：系统梳理本项目，总结复盘做得好的，可以做得更好的有哪些？本文重点
    
                    
    • 
                    
  • 【项目日记(九)】项目整体测试,优化以及缺陷分析
                        杭电码农-NEO
项目日记--高并发内存池项目日记c++内存池
                        
    博主CSDN主页:杭电码农-NEO ⏩专栏分类:项目日记-高并发内存池⏪ 代码仓库:NEO的学习日记 关注我带你做项目 开发环境:VisualStudio2022项目日记1.前言2.整体项目测试3.项目的效率上限分析4.效率上限问题的解决方法5.项目的缺陷分析6.项目总结1.前言整个项目的代码和框架就已经介绍完毕了,项目的所有代码在下面的链接:gitee代码仓库项目源代码本章重点:本篇文章着重讲解
    
                    
    • 
                    
  • 线上赚米的方法有哪些？这7个方法是目前最稳的！
                        高省APP大九

                        
    最近有很多的网友网友留言我，如何去赚钱？如何在网上赚钱？网上赚钱的方式有哪些？又有哪些正规可靠的兼职可以去做呢？为了让大家尽量少走弯路，少跳坑，今天我就把一些常见的赚钱项目总结一下，教大家如何在网上赚钱。1、社交电商现在有很多购物app，你只要分享链接，然后有人购买，你就可以得到佣金，就像分销一样，做好的还不错。小编使用高省app快3年的时间，不光省的多，每个月还能带来小几万的收入，这几年下来获得
    
                    
    • 
                    
  • 如何在网上赚钱，网络上做什么可以赚钱？
                        优惠券高省

                        
    相信大家都在思考如何去赚钱？如何在网上赚钱？网上赚钱的方式有哪些？又有哪些正规可靠的兼职可以去做呢？为了让大家尽量少走弯路，少跳坑，今天我就把一些常见的赚钱项目总结一下，教大家如何在网上赚钱。大家好，我是高省运营古楼导师。在开始本文的交流之前，我想向大家介绍一款网购省钱利器——高省APP，同时也是一项难得的零投入零成本的创业项目【高省】（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百
    
                    
    • 
                    
  • 今天工作效率挺高
                        情商晚期

                        
    今天周五，早上花20分钟阅读项目管理书籍大概10页，这已是第二遍阅读，好好利用我当前拥有充足时间期间去学习。自7月份以来，项目管理SOP任务我已重新完成更新，并初步给两位重要负责人查看，得到认可，我需要深入项目管理，为团队提升项目整体效率。今天工作上有一堆项目总结文档要编写，之前每周这一天得忙到加班才能完成，今天我提前准备好了相关文档模板，文档内容也从每天的记录中复制并快速整理，并按时提交给领导及
    
                    
    • 
                    
  • 跟着cherno手搓游戏引擎【24】开启2D引擎前的项目总结（包括前置知识汇总）
                        larito
游戏引擎
                        
    前置技术：vs属性解释：MSBuild的入门完整教程（包学包会）-CSDN博客配置界面：c++动态链接和静态链接：隐藏的细节：编译与链接_哔哩哔哩_bilibili【底层】动态链接库(dll)是如何工作的？_哔哩哔哩_bilibilicmake：软件构建:CMake快速入门_哔哩哔哩_bilibiliCMake保姆级教程【C/C++】_哔哩哔哩_bilibilipreake5：premake5实例
    
                    
    • 
                    
  • 如何完成一份优秀的工作汇报
                        影子喵喵喵

                        
    在日常工作中，需要汇报的场景有很多，有些同事不擅长编写文档，有些同事不擅长总结归纳，有些同事汇报工作抓不到重点、逻辑不清晰。工作汇报的本质是信息传递。Part1：日常常见的工作汇报场景1.个人工作总结2.项目总结3.个人日报/周报/月报4.项目提案5.项目立项申请/资源申请6.项目跟踪7.项目周报/月报8.项目例会9.会议纪要及跟踪10.突发情况通报Part2：一份有效的工作汇报包括哪些要素1.主
    
                    
    • 
                    
  • 2018-2021我的开源项目总结
                        wayn1

                        
    corwd-admin本人18年6月份毕业在武汉找了第一份java开发工作4500（面试时被hr压了500，武汉当时行情第一年5000），做的oa、库存管理相关系统，公司内系统架构主要是ssh，页面模板使用jsp，干了差不多大半年觉得提升有限，在19年3月份辞职，想着在家写一套自己的后台管理系统，于是就写出了crowd-adnin的第一个版本。当时写这个项目真的是废寝忘食，参考了网上很多的管理项目
    
                    
    • 
                    
  • 黑马头条项目总结之文章发布
                        Lil G.
javajava开发语言
                        
    文章发布功能/***新增文章**@paramdto参数*@return响应信息*/@OverridepublicResponseResultsubmitNews(WmNewsDtodto){//0.参数检验if(dto==null||dto.getContent()==null){returnResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVA
    
                    
    • 
                    
  • python实训
                        听风347
python开发语言数据分析数据库
                        
    一、项目目的与意义二、项目的内容与操作环境三、项目实施过程四、项目总结及收获一、项目目的与意义数据采集课程设计是计算机科学与技术专业的一门专业课程，涉及python编程、数据库技术等课程。课程设计的目的是使学生掌握数据采集以及预处理的技术，理解数据采集的原理以及实现，培养学生综合运用所学知识的能力。通过数据采集项目解决实际问题，培养学生严谨的学习态度和良好的学习习惯。数据采集课程是一门旨在教授如何
    
                    
    • 
                    
  • 项目前后端项目总结
                        夏野qwq
JavaWeb
                        
    一、前后端项目部署由于自己对前端部分来说并不是特别熟悉，前端的功能实现全部是跟着拉勾老师的步骤做，在做完整个项目后，在自己的云服务器上部署了前后端的项目并运行。通过整个流程下来，自己对于前后端的协同工作和数据处理等方面的认识，可以说是比之前那种模棱两可的状态清晰了很多，虽说自己从事前端工作的可能性不大，但实话实话，收获无疑是巨大的，以及开发的思路的锻炼。之前讲Linux服务器可能以后开发中会有多个
    
                    
    • 
                    
  • BiliBili评论案例
                        -_-你好-_-
typescriptreact.js前端
                        
    文章目录前言一、准备工作1.环境准备2.数据准备3.定义接口二、功能实现1.获取数据2.渲染评论数据（点赞，删除）3.用户发表评论（自动排序）4.最新最热列表渲染切换5.启动项目总结前言本次案例是基于react和typescript的项目实现，项目的实现步骤本文中有详细的讲解，在本文最后附有项目完整代码的github连接可供参考项目所实现的核心功能：1.渲染评论数据2.根据评论时间排序3.根据点赞
    
                    
    • 
                    
  • linux平台 LED情报板网关项目总结
                        QMCY_jason
linux运维服务器
                        
    LED情报板目前已经基本稳定主要存在两个版本LED1.5和LED2两个版本的主要差别是：1.1.5的配置文件存在本地2.0的存在平台需要通过接口从平台获取2.1.5的下发消息的时候需要同步返回2.0的是异步返回，所以1.5的要尽可能完成不然会导致发布平台卡在那里3.1.5上报状态是一个一个上报的，2.0上报是所有板子一起上报4.1.5有注册接口注册的时候需要把每个情报板支持的字体大小上报给平台2.
    
                    
    • 
                    
  • 大前端 vue项目总结1
                        黄毛火烧雪下
前端vue
                        
    一、运行demonpminstallvue中templatevue中exportdefault二、注意问题跨域通常为了减轻web服务器的负载，我们把js、css，img等静态资源分离到另一台独立域名的服务器上，在html页面中再通过相应的标签从不同域名下加载静态资源，而被浏览器允许webview第一次加载html很慢可以通过预加载js.babelrcbabel.config.jsRem自适应jsr
    
                    
    • 
                    
  • 在线教育后端开发项目总结
                        MONA ODYSSEY
Java开发后端javaspringbootmvc
                        
    文章目录一数据库访问接口1MyBatis2SpringDataJPA3SpringDataMongoDB二数据库1MySQL2MongoDB3Redis三开发规范化、响应格式与异常处理1开发规范2响应格式3异常处理四RabbitMQ五SpringCloud相关工具1Eureka2Ribbon3Feign4Zuul网关六搜索服务1ElasticSearch2Logstash七用户认证与授权1Spri
    
                    
    • 
                    
  • 分享一个关于 Vue3+Pinia+Koa+Three.js 全栈电商的项目总结
                        前端达人
javascript开发语言ecmascript前端
                        
    前言前几天一个朋友去义乌旅游，带回来很多小商品，就是一整个物美价廉，但是为什么线下购物和网购有的时候差别这么大（网购经常要退换货啊），为此我萌生了一个想法，3D是不是就可以实现在线看商品的细节了，退换货这么麻烦是不是可以省省了一、项目概述这个项目是对义务购app的一个模仿，相对于其官方app，我新增的亮点如下：商品排列布局使用瀑布流布局实现3D看商品功能实现3D看义乌商贸城同时，基础功能如下：使用
    
                    
    • 
                                
  • xml解析
                                    小猪猪08
xml
                                    
    1、DOM解析的步奏 
准备工作： 
   1.创建DocumentBuilderFactory的对象 
   2.创建DocumentBuilder对象 
   3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件 
   4.通过Document的getElem
    
                                
    • 
                                
  • 每个开发人员都需要了解的一个SQL技巧
                                    brotherlamp
linuxlinux视频linux教程linux自学linux资料
                                    
      
对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。 
使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： 
CREATE TABLE books ( 
  id &
    
                                
    • 
                                
  • Quartz——CronTrigger触发器
                                    eksliang
quartzCronTrigger
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 
CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。 二.Cron表达式介绍 1）Cron表达式规则表 
Quartz
    
                                
    • 
                                
  • Informatica基础
                                    18289753290
InformaticaMonitormanagerworkflowDesigner
                                    
    1. 
1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 
2）Workflow  Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 
3）Workflow  Monitor：监控Workflow和Session运行情况，生成日志和报告 
4）Repository  Manager：
    
                                
    • 
                                
  • linux下为程序创建启动和关闭的的sh文件，scrapyd为例
                                    酷的飞上天空
scrapy
                                    
    对于一些未提供service管理的程序  每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件 
  
下面以scrapy启动server为例，文件名为run.sh： 
  
  
#端口号，根据此端口号确定PID
PORT=6800
#启动命令所在目录
HOME='/home/jmscra/scrapy/'

#查询出监听了PORT端口
    
                                
    • 
                                
  • 人--自私与无私
                                    永夜-极光

                                    
                今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么? 
  
            从客观的角度来看,人有自私的行为,也有无私的
    
                                
    • 
                                
  • Ubuntu安装NS-3 环境脚本
                                    随便小屋
ubuntu
                                    
      
将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令： 
  
sudo ./ns3environment.sh >>result 
  
这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示 
  
  
com
    
                                
    • 
                                
  • 创业的简单感受
                                    aijuans
创业的简单感受
                                    
      
       2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。 
     今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。 
当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
    
                                
    • 
                                
  • 如何经营自己的独立人脉
                                    aoyouzi
如何经营自己的独立人脉
                                    
    独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。       现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。       以一个普通的银行柜员
    
                                
    • 
                                
  • JSP基础
                                    百合不是茶
jsp注释隐式对象
                                    
      
1,JSP语句的声明 
<%! 声明 %> 　　    声明：这个就是提供java代码声明变量、方法等的场所。

表达式 <%= 表达式 %> 　　   这个相当于赋值，可以在页面上显示表达式的结果，

程序代码段/小型指令　<% 程序代码片段 %>  
  
2,JSP的注释 
  
 <!-- --> 
    
                                
    • 
                                
  • web.xml之session-config、mime-mapping
                                    bijian1013
javaweb.xmlservletsession-configmime-mapping
                                    
    session-config 
1.定义： 
<session-config>
 <session-timeout>20</session-timeout>
</session-config> 
2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。 
  
mime-mapping 
1.定义： 
<mime-m
    
                                
    • 
                                
  • 互联网开放平台（1）
                                    Bill_chen
互联网qq新浪微博百度腾讯
                                    
    现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 
1.淘宝开放平台(TOP) 
网址：http://open.taobao.com/ 
依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。 
目前TOP的三条主线： 
TOP访问网站：open.taobao.com 
ISV后台：my.open.ta
    
                                
    • 
                                
  • 【MongoDB学习笔记九】MongoDB索引
                                    bit1129
mongodb
                                    
    索引 
 
 可以在任意列上建立索引 
 索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 
 使用索引可以加快查询,但同时会降低修改,插入等的性能 
 内嵌文档照样可以建立使用索引 
 测试数据 
  
  
var p1 = {
"name":"Jack",
"age&q
    
                                
    • 
                                
  • JDBC常用API之外的总结
                                    白糖_
jdbc
                                    
     做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。 
  
  
 
 ResultSetMetaData获取ResultSet对象的元数据信息 
 
    
                                
    • 
                                
  • apache VelocityEngine使用记录
                                    bozch
VelocityEngine
                                    
    VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。 
  
使用方法如下： 
    VelocityEngine engine = new VelocityEngine();// 定义模板引擎 
    Properties properties = new Properties();// 模板引擎属
    
                                
    • 
                                
  • 编程之美-快速找出故障机器
                                    bylijinnan
编程之美
                                    
    
package beautyOfCoding;

import java.util.Arrays;

public class TheLostID {

	/*编程之美 
	 假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。
		1.假设在某个时间得到一个数据文件ID的列表，是
    
                                
    • 
                                
  • 关于Java中redirect与forward的区别
                                    chenbowen00
javaservlet
                                    
    在Servlet中两种实现： 
 
forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); 
 
redirect方式：response.sendRedirect(“/somePage.jsp”); 
 
forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
    
                                
    • 
                                
  • [信号与系统]人体最关键的两个信号节点
                                    comsci
系统
                                    
     
 
 
        如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做 百汇穴, 另外一个节点在腰部,中医的名称叫做 命门 
 
        如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
    
                                
    • 
                                
  • oracle 存储过程执行权限
                                    daizj
oracle存储过程权限执行者调用者
                                    
    在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 
 
CREATE OR REPLACE PROCEDURE TestProc  
IS  
  fla
    
                                
    • 
                                
  • 为mysql数据库建立索引
                                    dengkane
mysql性能索引
                                    
    前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。  最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
    
                                
    • 
                                
  • 学习C语言常见误区 如何看懂一个程序 如何掌握一个程序以及几个小题目示例
                                    dcj3sjt126com
c算法
                                    
    如果看懂一个程序，分三步 
  
1、流程 
  
2、每个语句的功能 
  
3、试数 
  
如何学习一些小算法的程序 
尝试自己去编程解决它，大部分人都自己无法解决 
如果解决不了就看答案 
关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点 
看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义 
照着答案去敲 
调试错误 

    
                                
    • 
                                
  • centos6.3安装php5.4报错
                                    dcj3sjt126com
centos6
                                    
    报错内容如下: 
Resolving Dependencies 
--> Running transaction check 
---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed 
--> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for 
    
                                
    • 
                                
  • JSONP请求
                                    flyer0126
jsonp
                                    
      
    使用jsonp不能发起POST请求。 
It is not possible to make a JSONP POST request.
JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
    
                                
    • 
                                
  • Spring Security（03）——核心类简介
                                    234390216
Authentication
                                    
    核心类简介 
目录 
1.1     Authentication 
1.2     SecurityContextHolder 
1.3     AuthenticationManager和AuthenticationProvider 
1.3.1  &nb
    
                                
    • 
                                
  • 在CentOS上部署JAVA服务
                                    java--hhf
javajdkcentosJava服务
                                    
        本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行 
    
第一步：卸载旧Linux自带的JDK 
①查看本机JDK版本 
java -version 
   结果如下 
java version "1.6.0"
    
                                
    • 
                                
  • oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date]
                                    ldzyz007
oraclemysqlSQL Server
                                    
    oracle                                &n
    
                                
    • 
                                
  • 记Protocol Oriented Programming in Swift of WWDC 2015
                                    ningandjin
protocolWWDC 2015Swift2.0
                                    
    其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭， 把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。 
 
通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS
                                    rensanning
keepalived
                                    
    （一）Keepalived 
 
（1）安装 
 
# cd /usr/local/src
# wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz
# tar zxvf keepalived-1.2.15.tar.gz
# cd keepalived-1.2.15
# ./configure
# make &a
    
                                
    • 
                                
  • ORACLE数据库SCN和时间的互相转换
                                    tomcat_oracle
oraclesql
                                    
    SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换；  　　 
用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了；   　 
　操作方法：   　　1、通过dbms_f
    
                                
    • 
                                
  • Spring MVC 方法注解拦截器
                                    xp9802
spring mvc
                                    
    应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 
python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理 
先看一个实例,使用@access_required拦截：    
?      
    
                                
    •