Redis

Redis

Salvatore Sanfilippo 萨尔瓦托·桑菲利波--“Redis之父”

Salvatore在负责一个 page view 记录的系统，接收多个网站js发送来的页面访问记录数据，并存储之后展示给用户，最大负载每秒数千条页面记录，当时Salvatore在仅有硬件资源上无法用现有的数据库达到希望的性能。所以催生了redis的雏形 – 一段C程序

1. 概述

基于内存存储的，NoSql数据库 ( 非关系型数据库 )，存储结构 : key-value

Redis是一个开放源代码（BSD许可）内存中的数据结构存储，用作数据库、缓存和消息代理。

对于数据量多，数据交互效率要求高的场景，可以考虑使用redis

2. 安装

**下载：**https://redis.io/download

依次执行：

yum install gcc安装依赖

yum install tcl 安装依赖

tar -zxvf redis-4.0.14.tar.gz 解压

cd redis-4.0.14 进入解压目录

make MALLOC=libc 编译，并设置用标准的libc中的内存管理函数

make install 安装

3. 启动Redis

3.1 前台模式

默认配置启动(默认端口6379)
[root@zhj ~]# redis-server

3.2 守护进程(后台)模式

在redis解压根目录中找到配置文件模板(redis.conf)，复制到自定义位置：

[root@zhj ~]# cp redis.conf /usr/local/redis/7000/7000.conf

通过vi命令修改

daemonize yes  #后台模式

port 7000  #端口

pidfile /usr/local/redis/7000/7000.pid #记录进程号的文件位置
 
logfile /usr/local/redis/7000/7000.log #记录日志的文件位置

dir /usr/local/redis/7000  #redis的工作目录，用于保存自己的相关文件

bind 127.0.0.1 192.168.110.133 #允许以此ip访问redis，已达到对redis的保护

#最后启动redis： 
[root@zhj ~]# redis-server /usr/local/redis/7000/7000.conf

3.3 连接redis

#连接端口为6379 Host为127.0.0.1的redis服务器
[root@zhj ~]# redis-cli 

#连接端口为7000 Host为192.168.1.103的redis服务器
[root@zhj ~]# redis-cli -p 7000 -h 192.168.1.103

3.4 关闭

连接后，执行 shutdown 即可退出redis

3.5 性能测试

redis-benchmark -t get,spop -q -p 9001

4. 数据类型

4.1 String 【单值】

指令	描述
set	设置一个key/value
get	根据key获得对应的value
mset	一次设置多个key value
mget	一次获得多个key的value
getset getset age 19	获得原始key的值，同时设置新值
strlen	获得对应key存储value的长度
append	为对应key的value追加内容
getrange	截取value的内容,对原始的值没有影响
setex setex key ex value	设置一个key存活的有效期（秒）
psetex	设置一个key存活的有效期（豪秒）
setnx	只有当这个key不存在时等效set操作
msetnx	可以同时设置多个key，在key不存在时有效
decr	进行数值类型的-1操作
decrby	根据提供的数据进行减法操作
incr	进行数值类型的+1操作
incrby	根据提供的数据进行加法操作
incrbyfloat	根据提供的数据加入浮点数

keys * 查看所有key

ttl key 查看剩余存活时间

del key 删除key

select 5 切换到第6个库

flushDB 删除当前库的所有数据

4.2 List

指令	描述
lpush	将某个值加入到一个key列表头部
lpushx	同lpush,但是必须要保证这个key存在
rpush	将某个值加入到一个key列表末尾
rpushx	同rpush,但是必须要保证这个key存在
lpop	返回和移除列表的第一个元素
rpop	返回和移除列表的最后一个元素
lrange	获取某一个下标区间内的元素
llen	获取列表元素个数
lset lset key index value	设置某一个位置的元素(替换已有的某个值)
lindex lindex key index	获取某一个位置的元素
lrem lrem key 2 xxx	从列表头起，删除对应个数的指定元素
ltrim	保留列表中特定区间内的元素,将其他的元素删除
； linsert key after/before old new	在某一个元素之前，之后插入新元素

4.3 Set

指令	描述
sadd	为集合添加元素
smembers	显示集合中所有元素 无序
scard	返回集合中元素的个数
spop	随机返回并移除一个元素
smove smove setFrom setTo xxx	从一个集合中向另一个集合移动元素
srem	从集合中删除一个元素
sismember sismember set77 值	判断一个集合中是否含有这个元素
srandmember	随机返回元素，对原始数据没有影响
sdiff sdiff seta setb	减去两个集合中共有的元素
sinter	求交集
sunion	求并集

4.4 ZSet

指令	描述
zadd zadd key 10 a 5 b 30 c	添加一个有序集合元素，根据元素的score排序
zcard	返回集合的元素个数
zrange	返回一个范围内的元素
zrangebyscore	按照分数查找一个范围内的元素
zrank zrank key xx	返回对应元素的排名
zrevrank	返回对应元素倒序排名
zscore zscore key xxx	显示某一个元素的分数
zrem	移除某一个元素
zincrby zincrby key 10 lining	给某个特定元素加分

4.5 Hash

指令	描述
hset	设置一个key/value对
hget	获得一个key对应的value
hgetall	获得所有的key/value对
hdel	删除某一个key/value对
hexists	判断一个key是否存在
hkeys	获得所有的key
hvals	获得所有的value
hmset	设置多个key/value
hmget	获得多个key的value
hsetnx	设置一个不存在的key的值
hincrby hincrby key k 2	为value进行加法运算
hincrbyfloat	为value加入浮点值

5. 持久化

redis是内存型的nosql数据库，所以数据安全必须考虑，redis支持将数据持久化到磁盘。

5.1 RDB

5.1.1 原理

Snapshotting(RDB)机制的运行原理

1> 在某些时刻,Redis通过fork产生子进程,一个父进程的快照(副本)，

​ 其中有和父进程当前时刻相同的数据

2> 父进程继续处理client请求，子进程负责将快照(数据副本)写入临时文件

3> 子进程写完后，用临时文件替换原来的快照文件，然后子进程退出。

5.1.2 配置

save 900 1 #900秒超过1个key被修改

save 300 10 #300秒超过10个key被修改 （删除所有save项，则会关闭rdb）

dbfilename dump.rdb #快照文件名

stop-writes-on-bgsave-error yes #快照失败后是否继续写操作

rdbcompression yes #是否压缩快照文件

5.1.3 细节

1> 如果发生系统崩溃，则会丢失最近一次rdb之后的数据，所以如果项目不能接受这样的数据损失,还需要其他安全手段

2> 不适于实时性持久化，但其数据体量小，执行速度快，适合做数据版本控制

3> 如果数据量巨大，则创建子进程的时间长，导致redis卡顿，要谨慎设置save参数时间间隔大一些；

​ 或如果软件允许，可以每天在闲时手动同步（凌晨后…）

4> 将生成的快照文件，留在原地，则可以在重启redis后，保持数据状态

​ 将生产的快照文件，复制到其他redis服务中，可以方便的将数据移植过去

5.1.4 触发方式

1> 某一个save参数被满足

2> 执行 bgsave

3> 执行 save

4> redis服务关闭时

5.2 AOF

5.2.1 原理

1> Redis将每一个写操作(执行成功)，写入一个aof文件，

2> Redis重启时只要从头到尾执行一次aof文件，即可恢复据；

​ 也可以将aof文件复制到别的服务器，做数据移植

注意：在重启时，要恢复数据，如果rdb文件和aof文件同时存在，以AOF为准

5.2.2 配置

appendonly yes # 启动AOF机制

appendfsync always # 每次收到写命令就立即强制 写入磁盘，保证完全的持久化，但产生极大的IO开销(不推荐使用)

appendfsync everysec # 每秒钟强制写入磁盘一次，在性能和持久化方面做了很好的折中(推荐使用）

appendfsync no # 由操作系统决定何时同步，如果系统宕机则导致redis丢失不定数量数据

appendfilename “appendonly.aof” #设置aof文件名

5.2.3 细节

1> AOF文件会不断增长(可能比快照文件大几倍)，在极端情况下，可能会对硬盘空间造成压力

2> Redis重启时，需要重新执行一个可能非常大的AOF，时间会很长

3> AOF同步时间间隔小，数据更安全，理论上至多丢失1秒的数据，比rdb更擅长做更实时的持久化

5.3 AOF重写

5.3.1 原理

为了减小aof文件的体量，可以手动发送 bgrewriteaof 命令，则会创建子进程，生成更小体量的aof，然后替换掉旧的、大体量的aof文件。

5.3.2 配置

auto-aof-rewrite-percentage 100

auto-aof-rewrite-min-size 64mb

在体量超过64mb，且比上次重写后的体量增加了100%时自动触发重写

5.3.3 细节

1> 如果当前数据量巨大，则子进程创建过程会很耗时

2> 在替换aof文件时，如果旧aof很大，则删除它也是一个耗时的过程

6. 集群(另一篇配置)

6.1 原理

在处理大量复杂的数据时，基于主从的复制( replication ),将有效保证redis的高性能。

一个Redis主服务器，并为其关联多个从服务器，主服务器会将自己的数据状态不断的同步给从服务器。

所有读取操作负载到多个从服务器中，主服务器负责写操作

##6.2 配置

slaveof 192.168.1.103 7000 #成为 103的从机

主服务器的所有数据会在初始接收到从服务器的连接时全部发送到从服务器。之后每次主服务器执行完一个写操作，都会发送到从服务器

7. Java-Redis

<dependency>
    <groupId>redis.clientsgroupId>
    <artifactId>jedisartifactId>
    <version>2.9.0version>
dependency>

@Test
public void shouldAnswerWithTrue(){
    Jedis jedis = new Jedis("192.168.110.133", 6379);
    jedis.set("name","臧红久");
    System.out.println(jedis.get("name"));
}

8. Spring-Data-Redis

提供了一套API，实现了一整套Redis操作的方案，使得Java和Redis通信变得极其简单

<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>redis.clientsgroupId>
    <artifactId>jedisartifactId>
    <version>2.9.0version>
dependency>

<dependency>
    <groupId>org.springframework.datagroupId>
    <artifactId>spring-data-redisartifactId>
    <version>1.8.6.RELEASEversion>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>4.3.10.RELEASEversion>
dependency>

<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.9.8version>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>1.2.54version>
dependency>

8.1 配置

将Spring-Data-Reids的核心组件纳入工厂

<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-3.0.xsd">
    
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        
        <property name="maxIdle" value="1" />
        
        <property name="maxTotal" value="5" />
        <property name="minIdle" value="1">property>
        
        <property name="blockWhenExhausted" value="true" />
        
        <property name="maxWaitMillis" value="30000" />
        
        <property name="testOnBorrow" value="false" />
        
        <property name="testWhileIdle" value="false">property>
        
        <property name="minEvictableIdleTimeMillis" value="60000">property>
        
        <property name="timeBetweenEvictionRunsMillis" value="30000">property>
        
        <property name="numTestsPerEvictionRun" value="3">property>
        
        <property name="lifo" value="true">property>
    bean>

    
    <bean id="jedisConnectionFactory"
          class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        
        <property name="hostName" value="192.168.110.133">property>
        <property name="port" value="9001">property>
        
        <property name="poolConfig" ref="jedisPoolConfig">property>
    bean>

    
    <bean id="ss" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"      			id="jacks" />
    <bean class="com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer" id="fast">bean>
    
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
          p:connectionFactory-ref="jedisConnectionFactory"
          p:keySerializer-ref="ss"
          p:hashKeySerializer-ref="ss"
          p:hashValueSerializer-ref="fast"
          p:stringSerializer-ref="ss"
          p:valueSerializer-ref="fast"/>
beans>

8.2 测试

//spring测试集成
//注入RedisTemplate，自动转换为对应Operation
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AppTest
{
    @Resource(name = "redisTemplate") //spring-data-redis 会自动 将RedisTemplate转换为 XXOperations
    private ValueOperations<String,Object> vo;

    @Resource(name = "redisTemplate")
    private ListOperations<String,Object> lo;

    @Resource(name = "redisTemplate")
    private SetOperations<String,Object> so;

    @Resource(name = "redisTemplate")
    private ZSetOperations<String,Object> zo;

    @Resource(name = "redisTemplate")
    private HashOperations<String,String,Object> ho;

    @Test
    public void shouldAnswerWithTrue2(){
        vo.set("java",new User("臧红久",new Date()));
        User user = (User)vo.get("java");
        System.out.println(user);
        lo.leftPush("list",new User("臧红久",new Date()));
        so.add("set",new User("臧红久",new Date()));
        zo.add("zset",new User("臧红久",new Date()),1);
        ho.put("hash","user",new User("臧红久",new Date()));
    }
}

RedisTempalte 可以直接注入给 5中数据类型的 XXOperations引用

@Resource(name = "redisTemplate")   //PropertyEditor
    private ValueOperations<String,Object> valueOps;

    @Resource(name = "redisTemplate")   //PropertyEditor
    private ListOperations<String,Object> listOps;

    @Resource(name = "redisTemplate")   //PropertyEditor
    private SetOperations<String,Object> setOps;

    @Resource(name = "redisTemplate")   //PropertyEditor
    private ZSetOperations<String,Object> zsetOps;

    @Resource(name = "redisTemplate")   //PropertyEditor
    private HashOperations<String,String,Object> hashOps;

RedisTemplate 有一个子类 StringRedisTemplate

// 如果所有数据都是字符串，则可以选用此子类
public StringRedisTemplate() {
		RedisSerializer<String> stringSerializer = new StringRedisSerializer();
		setKeySerializer(stringSerializer);
		setValueSerializer(stringSerializer);
		setHashKeySerializer(stringSerializer);
		setHashValueSerializer(stringSerializer);
}

9. MyBatis-Redis-Cache

Mybatsi默认缓存对象 PerpetualCache，是本地缓存

9.1 定义缓存组件

org.apache.ibatis.cache.Cache

import org.apache.ibatis.cache.Cache;
...
// 自定义 Mybatis 缓存组件
public class RedisCache9 implements Cache{
    //存储 namespace
    private String id;
    private ReentrantReadWriteLock lock;//锁，保证线程安全
    public RedisCache9(){}

    // mybatis为一个mapper创建缓存对象时，会调用该构造，传入mapper的namespace
    public RedisCache9(String id) {//id=namespace
        this.lock = new ReentrantReadWriteLock();
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }

    /*
    	将数据缓存入Redis，key = “查询的sql”  value = "查询结果"	
    */
    public void putObject(Object key, Object value) {
        // 获取spring工厂
        WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
        // 获取RedisTemplate
        RedisTemplate<String,Object> rt = (RedisTemplate<String, Object>) context.getBean("redisTemplate");
        // 存入缓存到Redis
        ValueOperations<String, Object> vo = rt.opsForValue();
        vo.set(key.toString(),value);
    }

    /*
    	从redis中获取缓存数据， key = "查询时的sql"
    */
    public Object getObject(Object key) {
        // 获取spring工厂
        WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
        // 获取RedisTemplate
        RedisTemplate<String,Object> rt = (RedisTemplate<String, Object>) context.getBean("redisTemplate");
        // 从redis中查询缓存
        ValueOperations<String, Object> vo = rt.opsForValue();
        return vo.get(key.toString());
    }

    /*
    	删除某个缓存 key
    */
    public Object removeObject(Object key) {
        WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
        RedisTemplate<String,Object> rt = (RedisTemplate<String, Object>) context.getBean("redisTemplate");
        rt.delete(key.toString());
        return null;
    }

    /*
    	清空缓存
    */
    public void clear() {
        WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
        RedisTemplate<String,Object> rt = (RedisTemplate<String, Object>) context.getBean("redisTemplate");
        ValueOperations<String, Object> vo = rt.opsForValue();
        Set<String> keys = rt.keys("*" + id + "*");
        rt.delete(keys);
    }

    // 忽略
    public int getSize() {
        return 0;
    }

    // 返回一个锁对象
    public ReadWriteLock getReadWriteLock() {
        return this.lock;
    }
}

9.2 使用自定义的缓存组件

<mapper namespace="com.zhj.dao.UserDAO">
    
    <cache type="com.zhj.cache.RedisCache9"/>
    mapper>
 
  
10. Shiro-Redis-Cache
 
  
 
   
Cache：负责完成缓存数据的功能
 
   
CacheManager：负责管理Cache核心流程，重点是会创建Cache对象
 
  
 
  
10.1 定义Cache组件
 
  
 
   
org.apache.shiro.cache.Cache
 
  
 
  
//定义Cache类
import org.apache.shiro.cache.Cache;
....
/**
 * 负责将Shiro的 Realm查询到的 身份信息 和 权限信息 缓存如redis
 *
 * 此类需要RedisTemplate 对象
 */
public class ShiroCache9 implements Cache{
    //Cache对象由CacheManager 创建，并会传入缓存前缀
    private String name;//自定义属性,存储缓存前缀：“com.zhj.realm.MyRealm.authorizationCache”
    private RedisTemplate rt;//自定义属性，便于通信Redis
    public ShiroCache9(){}
    public ShiroCache9(String name){// 构造，为缓存前缀赋值
        System.out.println("ShiroCache's Name:"+name);
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public RedisTemplate getRt() {
        return rt;
    }
    public void setRt(RedisTemplate rt) {
        this.rt = rt;
    }

    ///以上自定义属性///

    /*
    	从缓存中取值
    	o = 用户名
    */
    public Object get(Object o) throws CacheException {
        System.out.println("Realm get Cache :"+o);
        return rt.opsForValue().get(name+":"+o.toString()); // key做了拼接 【前缀+“：”+用户名】
    }

    /*
    	将数据（权限信息）存入Redis
    	o = 用户名
    	o2 = 权限信息
    */
    public Object put(Object o, Object o2) throws CacheException {
        System.out.println("Realm save Cache :"+o.toString()+" -- "+o2);
        rt.opsForValue().set(name+":"+o.toString(),o2);// key做了拼接 【前缀+“：”+用户名】
        return null;
    }

    /*
    	删除缓存数据
    	o = 用户名
    */
    public Object remove(Object o) throws CacheException {
        System.out.println("Realm remove Cache :"+o.toString());
        rt.delete(name+":"+o.toString());// key做了拼接 【前缀+“：”+用户名】
        return null;
    }

    // 忽略
    public void clear() throws CacheException {
        System.out.println("clear~~");
    }

    // 忽略
    public int size() {
        System.out.println("size~~~~~~~~");
        return 0;
    }

    // 忽略
    public Set keys() {
        System.out.println("keys~~~~`");
        return null;
    }

    // 忽略
    public Collection values() {
        System.out.println("values~~~~~~");
        return null;
    }
}
 
  
10.2 定义CacheManager
 
  
// CacheManager，负责创建Cache对象
public class ShiroCacheManager9 extends AbstractCacheManager {

    private RedisTemplate rt;// 需要注入RedisTemplate

    public RedisTemplate getRt() {
        return rt;
    }

    public void setRt(RedisTemplate rt) {
        this.rt = rt;
    }

    @Override
    // 创建Cache对象，并传入前缀，供Cache中使用
    // 权限缓存prefix : com.zhj.realm.MyRealm.authorizationCache
    protected Cache createCache(String prefix) throws CacheException {
        ShiroCache9 cache = new ShiroCache9(prefix);//新建 自定义的Cache对象
        cache.setRt(rt);// 为缓存对象存入RedisTemplate，供缓存对象中通信Redis
        return cache;
    }
}
 
  
10.3 配置Cache和CacheManager
 
  
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx.xsd 				
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd">

    
    <bean class="com.zhj.cache.ShiroCacheManager9" id="cacheManager9">
        <property name="rt" ref="redisTemplate"/>
    bean>
    
    
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="realm1"/>
        
        <property name="cacheManager" ref="cacheManager9"/>
    bean>
    
    
    <bean id="realm1" class="com.zhj.realm.MyRealm">
        <property name="userService" ref="userServiceImpl"/>
        <property name="roleService" ref="roleServiceImpl"/>
        <property name="permService" ref="permServiceImpl"/>

        
        <property name="credentialsMatcher">
            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <property name="hashAlgorithmName" value="SHA-256"/>
                
                <property name="storedCredentialsHexEncoded" value="false"/>
                <property name="hashIterations" value="1024"/>
            bean>
        property>
        
        
    bean>

    
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
    bean>
beans>
 
  
11. Shiro-Redis-Session
 
  
 
   
SimpleSession : Session类型
 
   
SessionFactory : 直属SessionManager，默认为SimpleSessionFactory ,负责创建Session对象，默认为SimpleSession
 
   
SessionDAO : 直属SessionManager，负责将每个Session对象存储起来，需要定制这个组件，以集成redis
 
   
SessionManager : 直属SecurityManager，负责管理Session处理的核心调度过程。
 
  
 
  
11.1 定义SessionDAO
 
  
// 定义SessionDAO,负责存储Session对象
public class MySessionDAO extends AbstractSessionDAO {
    private RedisTemplate template;//需要注入RedisTemplate,以支持后续的Redis通信
    public RedisTemplate getTemplate() {
        return template;
    }
    public void setTemplate(RedisTemplate template) {
        this.template = template;
    }

    //将Session对象存入redis；（由SimpleSessionFactory创建的Session对象）
    protected Serializable doCreate(Session session) {
		// 生成sessionID
        Serializable sessionId = generateSessionId(session);
        //存入redis
        System.out.println("save session to redis");
        assignSessionId(session,sessionId);// 将sessionID赋值给Session对象
        // key = 前缀+sessionID  ;  value = session对象
        template.opsForValue().set("session"+sessionId,session);//将Session对象存入Redis，存入时定义了"前缀"
        return sessionId;
    }

    //从redis获取session对象，供项目使用
    @Override
    protected Session doReadSession(Serializable sessionId) {
        // 从redis获取session，获取时，也要定义 “前缀”； [前缀+sessionID]
        Session session = (Session)template.opsForValue().get("session"+sessionId);
        return session;
    }

    //session中数据变动时，要将session对象同步到redis
    @Override
    public void update(Session session) throws UnknownSessionException {
        System.out.println("update session");
        Serializable sessionId = session.getId();
        // 将session，覆盖存储到Redis
        template.opsForValue().set("session"+sessionId,session);
    }

    //session过期时，从redis中删除session
    @Override
    public void delete(Session session) {
        Serializable sessionId = session.getId();//获取sessionID
        // 从redis删除session
        template.delete("session"+sessionId);
    }

    //session检测时，需要获取所有session
    @Override
    public Collection<Session> getActiveSessions() {
        //从redis获取全部或部分session
        Set keys = template.keys("session*");//通过前缀获取Session
        List<Session> list = template.opsForValue().multiGet(keys);
        return list;
    }
}
 
  
11.2 配置SessionDAO
 
  
 
   
将SessionDAO注册在SessionManager中；
 
   
SessionManager注册在SecurityManager中；
 
   
注意RedisTemplate的序列化方式。
 
  
 
  

<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
    
    <property name="sessionDAO">
        <bean class="com.zhj.dao.MySessionDAO">
            <property name="template" ref="redisTemplate2"/>
        bean>
    property>
bean>


<bean id="ss" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
<bean id="redisTemplate2" class="org.springframework.data.redis.core.RedisTemplate"
      p:connectionFactory-ref="jedisConnectionFactory"
      p:keySerializer-ref="ss"/>


<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    <property name="realm" ref="myRealm"/>
    
    <property name="cacheManager" ref="cacheManager03"/>
    
    <property name="sessionManager" ref="sessionManager"/>
bean>
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(Redis)
        

            

                

                    
Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
                    
                    
华为云分布式缓存服务DCS 8月新特性发布
                        华为云PaaS服务小智
华为云分布式缓存
                        
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
                    
                    
Redis Key的过期策略
                        ArchManual
分布式架构分布式Java后端微服务架构redis
                        
Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
                    
                    
Redis:缓存击穿
                        我的程序快快跑啊
缓存redisjava
                        
缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
                    
                    
Redis 有哪些危险命令？如何防范？
                        花小疯
redis缓存数据库危险命令大数据
                        
Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
                    
                    
Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
                        朱杰jjj
缓存分布式
                        
分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
                    
                    
Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
                        weixin_34302561
数据库devops大数据
                        
1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
                    
                    
华为云分布式缓存服务DCS与开源服务差异对比
                        hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端
                        
分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
                    
                    
关于Redis集群同步/持久化/淘汰机制的详解
                        尾巴尖上的阳光
大数据redis数据库
                        
Redis是非常常用的KV数据库,使用内存以及HashMap进行存储的特点带来了高效的查询.本文将围绕Redis的常见开发使用场景,阐述在Redis集群中各个节点是如何进行数据同步,每个节点如何进行持久化以及在长期使用中如何对数据进行更新和淘汰.如果对Redis有更多的兴趣,可以查看我的技术博客:https://dingyuqi.com下面是Redis在开发过程中常用的几种使用场景.集群Redis
                    
                    
主流行架构
                        rainbowcheng
架构架构
                        
nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
                    
                    
网上商城项目总结 续
                        猫只i
javaweb电子商城结构
                        
前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
                    
                    
常用类库 Guava 简介
                        豆瑞瑞
java
                        
简介GoogleGuava是一个由Google开发的Java开源函数库。前身是GoogleCollectionsLibrary，提供了许多简化工具，如缓存、连接器、过滤器、关联数组等仓库代码GitCode-全球开发者的开源社区,开源代码托管平台参考https://github.com/google/guavahttps://github.com/google/guava/wikiRedisStre
                    
                    
2024Mysql And Redis基础与进阶操作系列（8）作者——LJS[含MySQL 创建、修改、跟新、重命名、删除视图等具体详步骤；注意点及常见报错问题所对应的解决方法]
                        肾透侧视攻城狮
MYSQLREDISAdvanceoperationredismysql数据库linuxsqlbashadb
                        
目录1MySQL视图1.概念2.作用3.特点4.具体如何操作实现MYSQL视图4.1创建视图语法示例查看表和视图查看视图的结构查看视图属性信息（比如：显示数据表的存储引擎、版本、数据行数和数据大小等）查看视图的详细定义信息4.2修改视图简介格式举例4.3更新视图简介下述结构中不可更新的视图补充说明举例更新视图视图包含聚合函数不可更新视图包含distinct不可更新视图包含goupby、having
                    
                    
自定义布隆过滤器解决缓存穿透
                        暗金烂狗
缓存
                        
什么是缓存穿透以及常见解决方案缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库，导致数据库压力提高，造成宕机。缓存穿透就是指用户访问那些在数据库和Redis中都不存在的数据，例如我们知道id采用自增策略，那么就不可能出现负数id，而如果不法分子使用负数id进行查询，那么这些请求都会穿过Redis直接向数据库发送请求，从而导致数据库压力骤增，导致数
                    
                    
Redis 为什么这么快？
                        小海海不怕困难
Redisredis
                        
决定Redis请求效率的因素主要是三个方面，分别是网络、cpu、内存。在网络层面，Redis采用多路复用的设计，提升了并发处理的连接数，不过这个阶段，Server端的所有IO操作，都是由同一个主线程处理的这个时候IO的瓶颈就会影响到Redis端的整体处理性能。所以从Redis6.0开始，在多路复用及层面增加了多线程的处理，来优化IO处理的能力不过，具体的数据操作仍然是由主线程来处理的，所以我们可以
                    
                    
Redis 集群
                        確定饿的猫
redislinux
                        
目录Redis主从复制Redis主从复制简介Redis主从复制的作用Redis主从复制流程搭建Redis主从复制master节点slave节点验证哨兵故障转移机制部署哨兵Redis集群作用数据分区高可用Redis集群Redis高可用实现的方式有持久化、主从复制、哨兵、集群，与持久化不同，另外三种方式都是属于集群，之前已经分析了解过两种持久化模式了，现在了解另外几种方式Redis主从复制Redis主
                    
                    
Redisson分布式锁实现原理和使用
                        牧竹子
springboot#redisRedissonredis
                        
常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
                    
                    
分布式框架Celery七(Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警)
                        yjjpp2301
Celery分布式djangopython后端
                        
Django中集成方式安装模块pipinstallDjango==3.2.22pipinstallcelerypipinstallredispipinstalleventlet#在windows环境下需要安装eventlet包-----------pipinstalldjango-celery-beatpipinstalldjango-celery-resultspipinstalldjango-
                    
                    
Redis的持久化和高可用性
                        小辛学西嘎嘎
redis数据库缓存
                        
目录一、淘汰策略1、背景2、淘汰策略二、持久化1、背景2、fork进程写时复制机制3、Redis持久化方式1、aof2、rdb三、高可用1、主从复制2、Redis哨兵模式3、Rediscluster集群一、淘汰策略1、背景首先Redis是一个内存数据库，将所有数据存放在内存中，通过对K值进行hash后存储在散列表中。有一个小问题Redis数据库占96G，但为什么最终占满只有48G呢。因为中间有个过
                    
                    
【Redis】Redis缓存
                        1886i
JavaRedis缓存redis数据库
                        
目录一、缓存1、概念2、作用3、缺点二、缓存模型三、缓存的更新1、更新策略2、主动更新的三种模式1.cacheasidepattern2.read/writethroughpattern3.writebehindcachingpattern3、线程安全问题1.缓存删除还是更新缓存2.先删除缓存后操作数据库3.先操作数据库后删除缓存4.如何保证缓存与数据库操作同时成功或失败4、最佳选择一、缓存1、概
                    
                    
Windows系统下安装Redis
                        bjzhang75
windowsredis数据库
                        
文章目录1、下载Redis安装包2、解压压缩包3、运行Redis4、Redis连接检测5、Redis相关设置5.1设置环境变量PATH5.2Redis配置文件修改1、下载Redis安装包Windows版本的Redis可以在Github中下载：下载Redis2、解压压缩包将下载的压缩包解压到某个目录下，比如：C:\redis。3、运行Redis在cmd窗口中运行命令redis-serverredis
                    
                    
实现多级缓存的六种策略方法
                        Kixuan214
缓存redisrabbitmq
                        
保证多级缓存数据一致性是一个复杂的任务，尤其是在分布式和高并发环境中。以下是一些常见的方法和策略，可以帮助实现多级缓存的数据一致性1.缓存失效策略1.1主动失效在更新数据库时，主动使相关缓存失效。步骤：更新数据库删除或失效缓存publicclassCacheService{privateLocalCachelocalCache;privateRedisCacheredisCache;private
                    
                    
redis-shake v4全量增量同步redis数据
                        nangonghen
redisredis数据库缓存redis-shake
                        
1概述RedisShake是一个用于处理和迁移Redis数据的工具，github地址是https://github.com/tair-opensource/RedisShake。它提供以下特性：1）Redis兼容性：RedisShake兼容从2.8到7.2的Redis版本，并支持各种部署方式，包括单机，主从，哨兵和集群。2）云服务兼容性：RedisShake与主流云服务提供商提供的流行Redis-
                    
                    
redis,codis,云redis
                        shuff1e

                        
redis的分布式解决方式--codis（转）https://www.cnblogs.com/softidea/p/5365640.htmlhttps://help.aliyun.com/document_detail/57797.html?spm=5176.173352.925244.2.bF70Gb
                    
                    
Redis总结（八）redis单线程还是多线程问题
                        卢小记

                        
redis为什么可以支持高并发和它内部的工作模式有不可分割的关系：绝大部分请求是纯粹的内存操作（非常快速）采用单线程,避免了不必要的上下文切换和竞争条件非阻塞IO-IO多路复用Redis客户端对服务端的每次调用都经历了发送命令，执行命令，返回结果三个过程。其中执行命令阶段，由于Redis是单线程来处理命令的，所有到达服务端的命令都不会立刻执行，所有的命令都会进入一个队列中，然后逐个执行，并且多个客
                    
                    
Java 使用 Redis
                        lly202406
开发语言
                        
Java使用Redis1.引言Redis是一个开源的高性能键值对数据库。它支持多种类型的数据结构，如字符串、列表、集合、散列表等，适用于多种场景，如缓存、消息队列等。Java是一种广泛使用的编程语言，它在企业级应用中有着广泛的应用。在Java应用中，使用Redis可以提高数据访问速度，减轻数据库的压力。本文将介绍如何在Java应用中使用Redis。2.准备工作在开始使用Redis之前，需要确保已经
                    
                    
Redis数据结构—跳跃表 skiplist
                        马卫斌 前端工程师
skiplist
                        
跳跃表（Skiplist）是Redis中用于实现有序集合（SortedSet）的一种高效数据结构。以下是关于Redis中跳跃表（Skiplist）的关键特性和工作原理的概览：基本概念层级结构：跳跃表通过多层次的链表组成，每一层都是下一层的稀疏视图，顶层最快地遍历整个链表，而底层则是完全连通所有节点的传统链表结构。这样的设计使得查询操作能够快速跳过大量不需要检查的元素。有序集合：每个节点（或称为元素
                    
                    
Redis安装详解（单机安装，sentinel哨兵模式，Cluster模式）
                        dream21st
中间件学习笔记sentinelredisjava
                        
文章目录1Redis单机安装1.1windows中安装1.2linux中安装2Redis主从复制安装3Redis哨兵模式安装4Springboot项目操作RedisSentinel集群5官方cluster分区搭建5.1部署架构5.2RedisCluster的优势5.3集群搭建6Springboot项目操作Cluster集群1Redis单机安装Redis安装包可以从官网下载，也可以在redis的官方
                    
                    
Redis哨兵模式(Sentinel)详解
                        水木渔樵
Redisredis
                        
目录文章目录一、Sentinel1.何为Sentinel2.Sentinel启动流程当一个Sentinel启动时，它需要执行以下步骤：2.1初始化服务器2.2使用Sentinel专用代码2.3初始化Sentinel状态2.4初始化Sentinel状态的masters属性2.5创建连向主服务器的网络连接3.Sentinel获取主服务器信息4.Sentinel获取从服务器信息5.Sentinel与主从
                    
                    
Redis Sentinel（哨兵）详解
                        dlwlrma ⥳
Java八股框架redissentinel数据库
                        
目录一：什么是Sentinel（哨兵）二：Sentinel有什么用1.监控2.故障转移3通知4.配置提供三：Sentinel如何检测master节点宕机1.主观下线2.客观下线四：Sentinel是如何选举出新的master1.slave的优先级2.复制进度3.runid五：如何在sentinel集群中选择出Leader前言：有关Redis的基础知识可以参照我之前写的文章Redis必知必会的知识在
                    
                                
java观察者模式
                                    3213213333332132
java设计模式游戏观察者模式
                                    
观察者模式——顾名思义，就是一个对象观察另一个对象，当被观察的对象发生变化时，观察者也会跟着变化。 
 
在日常中，我们配java环境变量时，设置一个JAVAHOME变量,这就是被观察者，使用了JAVAHOME变量的对象都是观察者，一旦JAVAHOME的路径改动，其他的也会跟着改动。 
 
这样的例子很多，我想用小时候玩的老鹰捉小鸡游戏来简单的描绘观察者模式。 
 
老鹰会变成观察者，母鸡和小鸡是
                                
                                
TFS RESTful API 模拟上传测试
                                    ronin47

                                    
       TFS RESTful API 模拟上传测试。 
　　 
细节参看这里：https://github.com/alibaba/nginx-tfs/blob/master/TFS_RESTful_API.markdown 
模拟POST上传一个图片： 
curl --data-binary @/opt/tfs.png http
                                
                                
PHP常用设计模式单例, 工厂, 观察者, 责任链, 装饰, 策略,适配,桥接模式
                                    dcj3sjt126com
设计模式PHP
                                    
// 多态, 在JAVA中是这样用的, 其实在PHP当中可以自然消除, 因为参数是动态的, 你传什么过来都可以, 不限制类型, 直接调用类的方法
abstract class Tiger {
    public abstract function climb();
}

class XTiger extends Tiger {
    public function  climb()
                                
                                
hibernate
                                    171815164
Hibernate
                                    
main,save 
 
Configuration conf =new Configuration().configure();
SessionFactory sf=conf.buildSessionFactory();
Session sess=sf.openSession();
Transaction tx=sess.beginTransaction();

News a=new 
                                
                                
Ant实例分析
                                    g21121
ant
                                    
        下面是一个Ant构建文件的实例，通过这个实例我们可以很清楚的理顺构建一个项目的顺序及依赖关系，从而编写出更加合理的构建文件。 
  
        下面是build.xml的代码： 
<?xml version="1
                                
                                
[简单]工作记录_接口返回405原因
                                    53873039oycg
工作
                                    
         最近调接口时候一直报错，错误信息是: 
      
responseCode:405
responseMsg:Method Not Allowed 
       接口请求方式Post. 
                                
                                
关于java.lang.ClassNotFoundException 和 java.lang.NoClassDefFoundError 的区别
                                    程序员是怎么炼成的

                                    
  
 真正完成类的加载工作是通过调用 defineClass来实现的； 
 而启动类的加载过程是通过调用 loadClass来实现的； 
 就是类加载器分为加载和定义 
   
 protected Class<?> findClass(String name) throws ClassNotFoundExcept
                                
                                
JDBC学习笔记-JDBC详细的操作流程
                                    aijuans
jdbc
                                    
所有的JDBC应用程序都具有下面的基本流程：　　1、加载数据库驱动并建立到数据库的连接。　　2、执行SQL语句。　　3、处理结果。　　4、从数据库断开连接释放资源。 
下面我们就来仔细看一看每一个步骤： 
其实按照上面所说每个阶段都可得单独拿出来写成一个独立的类方法文件。共别的应用来调用。 
1、加载数据库驱动并建立到数据库的连接： 
     Html代码    
 
 St
                                
                                
rome创建rss
                                    antonyup_2006
tomcatcmsxmlstrutsOpera
                                    
引用   
1.RSS标准 
 
RSS标准比较混乱，主要有以下3个系列 
 
 RSS 0.9x / 2.0 : RSS技术诞生于1999年的网景公司(Netscape)，其发布了一个0.9版本的规范。2001年，RSS技术标准的发展工作被Userland Software公司的戴夫 温那(Dave Winer)所接手。陆续发布了0.9x的系列版本。当W3C小组发布RSS 1.0后，Dave W
                                
                                
html表格和表单基础
                                    百合不是茶
html表格表单meta锚点
                                    
第一次用html来写东西,感觉压力山大,每次看见别人发的都是比较牛逼的 再看看自己什么都还不会, 
  
html是一种标记语言,其实很简单都是固定的格式 
  
_----------------------------------------表格和表单 
表格是html的重要组成部分,表格用在body里面的 
主要用法如下; 
<table>

     &
                                
                                
ibatis如何传入完整的sql语句
                                    bijian1013
javasqlibatis
                                    
        ibatis如何传入完整的sql语句？进一步说，String str ="select * from test_table"，我想把str传入ibatis中执行，是传递整条sql语句。 
        解决办法： 
<
                                
                                
精通Oracle10编程SQL(14)开发动态SQL
                                    bijian1013
oracle数据库plsql
                                    
/*
 *开发动态SQL
 */
--使用EXECUTE IMMEDIATE处理DDL操作
CREATE OR REPLACE PROCEDURE drop_table(table_name varchar2)
is
   sql_statement varchar2(100);
begin
   sql_statement:='DROP TABLE '||table_name;

                                
                                
【Linux命令】Linux工作中常用命令
                                    bit1129
linux命令
                                    
不断的总结工作中常用的Linux命令 
  
1.查看端口被哪个进程占用 
  
通过这个命令可以得到占用8085端口的进程号，然后通过ps -ef|grep 进程号得到进程的详细信息 
  
netstat -anp | grep 8085 
  
察看进程ID对应的进程占用的端口号 
  
netstat -anp | grep 进程ID 
&
                                
                                
优秀网站和文档收集
                                    白糖_
网站
                                    
集成 Flex, Spring, Hibernate 构建应用程序 
  
性能测试工具-JMeter 
  
Hmtl5-IOCN网站 
  
Oracle精简版教程网站 
  
鸟哥的linux私房菜 
  
Jetty中文文档 
  
50个jquery必备代码片段 
  
swfobject.js检测flash版本号工具
                                
                                
angular.extend
                                    boyitech
AngularJSangular.extendAngularJS API
                                    
angular.extend   复制src对象中的属性去dst对象中. 支持多个src对象. 如果你不想改变一个对象，你可以把dst设为空对象{}: var object = angular.extend({}, object1, object2). 注意: angular.extend不支持递归复制.    使用方法:   angular.extend(dst, src);    参数:   
                                
                                
java-谷歌面试题-设计方便提取中数的数据结构
                                    bylijinnan
java
                                    
网上找了一下这道题的解答，但都是提供思路，没有提供具体实现。其中使用大小堆这个思路看似简单，但实现起来要考虑很多。 
以下分别用排序数组和大小堆来实现。 
使用大小堆： 
 

import java.util.Arrays;

public class MedianInHeap {
	/**
	 * 题目：设计方便提取中数的数据结构
	 * 设计一个数据结构，其中包含两个函数，1.插
                                
                                
ajaxFileUpload 针对 ie jquery 1.7+不能使用问题修复版本
                                    Chen.H
ajaxFileUploadie6ie7ie8ie9
                                    
jQuery.extend({
	handleError: function( s, xhr, status, e ) 		{
		// If a local callback was specified, fire it
				if ( s.error ) {
					s.error.call( s.context || s, xhr, status, e );
				}


                                
                                
[机器人制造原则]机器人的电池和存储器必须可以替换
                                    comsci
制造
                                    
 
 
       机器人的身体随时随地可能被外来力量所破坏,但是如果机器人的存储器和电池可以更换,那么这个机器人的思维和记忆力就可以保存下来,即使身体受到伤害,在把存储器取下来安装到一个新的身体上之后,原有的性格和能力都可以继续维持..... 
 
       另外,如果一
                                
                                
Oracle Multitable INSERT 的用法
                                    daizj
oracle
                                    
转载Oracle笔记-Multitable INSERT 的用法 
 
http://blog.chinaunix.net/uid-8504518-id-3310531.html 
 
一、Insert基础用法 
 
语法： 
 
    Insert Into 表名 (字段1,字段2,字段3...） 
 
    Values (值1,
                                
                                
专访黑客历史学家George Dyson
                                    datamachine
on
                                    
20世纪最具威力的两项发明——核弹和计算机出自同一时代、同一群年青人。可是，与大名鼎鼎的曼哈顿计划（第二次世界大战中美国原子弹研究计划）相 比，计算机的起源显得默默无闻。出身计算机世家的历史学家George Dyson在其新书《图灵大教堂》（Turing’s Cathedral）中讲述了阿兰·图灵、约翰·冯·诺依曼等一帮子天才小子创造计算机及预见计算机未来
                                
                                
小学6年级英语单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
always 总是 
rice 水稻，米饭 
before 在...之前 
live 生活，居住 
  
usual 通常的 
early 早的 
begin 开始 
month 月份 
  
year 年 
last 最后的 
east 东方的 
high 高的 
  
far 远的 
window 窗户 
world 世界 
than 比...更 
  
                                
                                
在线IT教育和在线IT高端教育
                                    dcj3sjt126com
教育
                                    
codecademy 
http://www.codecademy.com   codeschool 
https://www.codeschool.com   teamtreehouse 
http://teamtreehouse.com   lynda 
http://www.lynda.com/   Coursera 
https://www.coursera.
                                
                                
Struts2 xml校验框架所定义的校验文件
                                    蕃薯耀
Struts2 xml校验Struts2 xml校验框架Struts2校验
                                    
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年7月11日 15:54:59 星期六 
http://fa
                                
                                
mac下安装rar和unrar命令
                                    hanqunfeng
mac
                                    
1.下载：http://www.rarlab.com/download.htm  选择 
RAR 5.21 for Mac OS X   2.解压下载后的文件   tar -zxvf rarosx-5.2.1.tar   3.cd rar   sudo install -c -o $USER unrar /bin #输入当前用户登录密码   sudo install -c -o $USER rar
                                
                                
三种将list转换为map的方法
                                    jackyrong
list
                                    
  在本文中，介绍三种将list转换为map的方法： 
 
1） 传统方法 
 
假设有某个类如下 
   

class Movie {
    
    private Integer rank;
    private String description;
    
    public Movie(Integer rank, String des
                                
                                
年轻程序员需要学习的5大经验
                                    lampcy
工作PHP程序员
                                    
在过去的7年半时间里，我带过的软件实习生超过一打，也看到过数以百计的学生和毕业生的档案。我发现很多事情他们都需要学习。或许你会说，我说的不就是某种特定的技术、算法、数学，或者其他特定形式的知识吗？没错，这的确是需要学习的，但却并不是最重要的事情。他们需要学习的最重要的东西是“自我规范”。这些规范就是：尽可能地写出最简洁的代码；如果代码后期会因为改动而变得凌乱不堪就得重构；尽量删除没用的代码，并添加
                                
                                
评“女孩遭野蛮引产致终身不育 60万赔偿款1分未得”医腐深入骨髓
                                    nannan408

                                    
先来看南方网的一则报道： 
 

再正常不过的结婚、生子，对于29岁的郑畅来说，却是一个永远也无法实现的梦想。从2010年到2015年，从24岁到29岁，一张张新旧不一的诊断书记录了她病情的同时，也清晰地记下了她人生的悲哀。

　　粗暴手术让人发寒

　　2010年7月，在酒店做服务员的郑畅发现自己怀孕了，可男朋友却联系不上。在没有和家人商量的情况下，她决定堕胎。

　　12月5日，
                                
                                
使用jQuery为input输入框绑定回车键事件 VS 为a标签绑定click事件
                                    Everyday都不同
jspinput回车键绑定clickenter
                                    
假设如题所示的事件为同一个，必须先把该js函数抽离出来，该函数定义了监听的处理： 
  
function search() {
	//监听函数略......	
} 
  
为input框绑定回车事件，当用户在文本框中输入搜索关键字时，按回车键，即可触发search(): 
  
//回车绑定
$(".search").keydown(fun
                                
                                
EXT学习记录
                                    tntxia
ext
                                    
  
1. 准备 
  
（1） 官网：http://www.sencha.com/ 
  
里面有源代码和API文档下载。 
  
EXT的域名已经从www.extjs.com改成了www.sencha.com ，但extjs这个域名会自动转到sencha上。 
  
（2）帮助文档： 
  
想要查看EXT的官方文档的话，可以去这里h
                                
                                
mybatis3的mapper文件报Referenced file contains errors
                                    xingguangsixian
mybatis
                                    
最近使用mybatis.3.1.0时无意中碰到一个问题： 
The errors below were detected when validating the file "mybatis-3-mapper.dtd" via the file "account-mapper.xml".  In most cases these errors can be d
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.