起一个好听的名字
起一个好听的名字

Java Spring mvc 操作 Redis 及 Redis 集群

Redis 是什么，能做什么

Redis 是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel 提供高可用，通过 Redis Cluster 提供自动分区。(摘自Redis 官网)

作为内存数据库，在现代互联网 web 系统中，还是主要将 Redis 作为缓存使用。大型互联网 Web 系统对性能要求很高，而在前端和数据层之间增加数据缓存已成为必不可少的手段之一，当前比较流行的两个技术就是 Redis 和 Memcached，至于两者有什么区别，不是本文要说的内容。本文主要讲 Java web 如何操作 Redis 及 Redis 集群。

一般 Java 程序操作Redis

Redis 提供了多种语言的客户端，在 Java 中最流行的是 Jedis 。访问可查看源码及使用方式。目前 Jedis 最新版本是2.9.0。无论是单机还是集群，Jedis 都有很详细的说明和实例代码，这里只做简单说明。如果用 Maven 做包管理，需要引用  jedis 包，本例使用最新的2.9.0版本，如下：

1
2
3
4
5
< dependency >
       < groupId >redis.clients groupId >
       < artifactId >jedis artifactId >
       < version >2.9.0 version >
dependency >　　

操作 Redis 单机

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
 
/**
  * Created by fengdezitai on 2016/10/9.
  */
public class JedisClient {
 
     private static final String host= "192.168.31.121" ;
 
     private static final JedisClient jedisClient = new JedisClient();
 
     private Jedis jedis = null ;
     /**
      * 私有构造函数
      */
     private JedisClient(){}
 
     public static JedisClient getInstance(){
         return jedisClient;
     }
 
     private JedisPoolConfig getPoolConfig(){
         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
         jedisPoolConfig.setMaxIdle( 10 );
         jedisPoolConfig.setMaxTotal( 100 );
         jedisPoolConfig.setMaxWaitMillis( 3000 );
         return jedisPoolConfig;
     }
 
     /**
      * 添加
      * @param key
      * @param value
      * @return
      * @throws Exception
      */
     public Boolean add(String key,String value) throws Exception{
         JedisPool pool = new JedisPool(getPoolConfig(),host);
         Jedis jedis = null ;
         try {
             jedis = pool.getResource();
             if (jedis.exists(key)){
                 throw new Exception(String.format( "key (%s) 已存在 " ,key));
             }
             jedis.set(key,value);
 
         } catch (Exception e){
             throw e;
         }
         finally {
             if (jedis!= null ){
                 jedis.close();
             }
         }
         pool.destroy();
         return true ;
     }
 
     /**
      * 获取值
      * @param key
      * @return
      * @throws Exception
      */
     public String get(String key) throws Exception{
         JedisPool pool = new JedisPool(getPoolConfig(),host);
         Jedis jedis = null ;
         String result = "" ;
         try {
             jedis = pool.getResource();
             result = jedis.get(key);
         } catch (Exception e){
             throw e;
         }
         finally {
             if (jedis!= null ){
                 jedis.close();
             }
         }
         pool.destroy();
         return result;
     }
 
     public static void main(String[] args) {
         JedisClient jedisClient = JedisClient.getInstance();
         try {
             /*Boolean result = jedisClient.add("hello", "redis1");
             if(result){
                 System.out.println("success");
             }*/
 
             System.out.println(jedisClient.get( "hello" ));
         } catch (Exception e){
             e.printStackTrace();
         }
     }
}

操作 redis 集群

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import redis.clients.jedis.*;
import java.util.HashSet;
import java.util.Set;
 
/**
  * Created by fengdezitai on 2016/10/13.
  */
public class JedisClusterClient {
 
     private static int count = 0 ;
 
     private static final JedisClusterClient redisClusterClient = new JedisClusterClient();
 
     /**
      * 私有构造函数
      */
     private JedisClusterClient() {}
 
     public static JedisClusterClient getInstance() {
         return redisClusterClient;
     }
 
     private JedisPoolConfig getPoolConfig(){
         JedisPoolConfig config = new JedisPoolConfig();
         config.setMaxTotal( 1000 );
         config.setMaxIdle( 100 );
         config.setTestOnBorrow( true );
         return config;
     }
 
     public void SaveRedisCluster() {
         Set jedisClusterNodes = new HashSet();
         jedisClusterNodes.add( new HostAndPort( "192.168.31.245" , 7000 ));
         jedisClusterNodes.add( new HostAndPort( "192.168.31.245" , 7001 ));
         jedisClusterNodes.add( new HostAndPort( "192.168.31.245" , 7002 ));
         jedisClusterNodes.add( new HostAndPort( "192.168.31.210" , 7003 ));
         jedisClusterNodes.add( new HostAndPort( "192.168.31.210" , 7004 ));
         jedisClusterNodes.add( new HostAndPort( "192.168.31.210" , 7005 ));
 
         JedisCluster jc = new JedisCluster(jedisClusterNodes,getPoolConfig());
         jc.set( "cluster" , "this is a redis cluster" );
         String result = jc.get( "cluster" );
         System.out.println(result);
     }
 
     public static void main(String[] args) {
         JedisClusterClient jedisClusterClient = JedisClusterClient.getInstance();
         jedisClusterClient.SaveRedisCluster();
     }
}　　

spring mvc 操作 Redis

在 Spring mvc 中操作 Redis ，首先当然要搭好 Spring mvc 框架了。以下是在假设 Spring mvc 环境已经架好的情况下。本例中 Spring 版本为 4.3.2 RELEASE。关于 Spring 的 maven 引用如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
4.3.2.RELEASE< /spring .version>
 
    
    
       org.springframework< /groupId >
       spring-core< /artifactId >
       ${spring.version}< /version >
      
        
           commons-logging< /groupId >
           commons-logging< /artifactId >
         < /exclusion >
       < /exclusions >
     < /dependency >
 
    
       org.springframework< /groupId >
       spring-web< /artifactId >
       ${spring.version}< /version >
     < /dependency >
 
    
       org.springframework< /groupId >
       spring-oxm< /artifactId >
       ${spring.version}< /version >
     < /dependency >
 
    
       org.springframework< /groupId >
       spring-tx< /artifactId >
       ${spring.version}< /version >
     < /dependency >
 
    
       org.springframework< /groupId >
       spring-jdbc< /artifactId >
       ${spring.version}< /version >
     < /dependency >
 
    
       org.springframework< /groupId >
       spring-webmvc< /artifactId >
       ${spring.version}< /version >
      
        
           commons-logging< /groupId >
           commons-logging< /artifactId >
         < /exclusion >
       < /exclusions >
     < /dependency >
 
    
       org.springframework< /groupId >
       spring-aop< /artifactId >
       ${spring.version}< /version >
     < /dependency >
 
    
       org.springframework< /groupId >
       spring-context-support< /artifactId >
       ${spring.version}< /version >
     < /dependency >
 
 
    
       org.springframework< /groupId >
       spring- test < /artifactId >
       ${spring.version}< /version >
     < /dependency >
    

操作 Redis 单机

只用 Jedis 自己实现注入（区别于下面的引用spring-data-redis） 

把前面的 JedisClient 代码拿过来引用即可，只需实现一个访问 Redis 的 Service ，就可以集成到 Spring mvc 。Service 代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import org.springframework.stereotype.Service;
import util.JedisClient;
 
/**
  * Created by fengdezitai on 2016/10/9.
  */
@Service
public class RedisService {
 
     public String get(String key) throws Exception{
         JedisClient jedisClient = JedisClient.getInstance(); //上面实现的JedisClient
         String result = "" ;
         try {
             result = jedisClient.get( "hello" );
         } catch (Exception e){
             throw e;
         }
         return result;
     }
}

Controller 实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Controller
@RequestMapping (value = "redisAllInOne" )
public class RedisAllInOneController {
 
     @Autowired
     private RedisService redisService;
 
     @RequestMapping (value = "get" ,method = RequestMethod.GET)
     @ResponseBody
     public Object getByMyService(String key){
         try {
             String result = redisService.get(key);
             return result;
         } catch (Exception e){
             e.printStackTrace();
         }
         return null ;
     }
}　　

用 spring-data-redis 包做集成

上面是自己实现的注入，这里用 spring-data-redis 进行集成，只需简单配置即可，需要引用 maven 包如下，版本为目前最新版 1.7.2.RELEASE：

1
2
3
4
5
       org.springframework.data< /groupId >
       spring-data-redis< /artifactId >
       1.7.2.RELEASE< /version >
     < /dependency >

使用 spring-data-redis ，即省去了自己实现注入的过程，通过它提供的一些配置，即可实现连接池配置、RedisTemplate 配置、JedisConnectionFactory 配置；通过 JedisConnectionFactory 可配置连接池参数、redis 服务器、端口、密码、超时时间、database索引等；RedisTemplate 即注入的bean ，可以使用 RedisTemplate 自动注入的实体进行 redis 的一系列操作，具体看配置；

redis 服务属性配置文件：

1
2
3
4
5
6
7
redis.maxIdle=300
redis.maxWait=3000
redis.testOnBorrow= true
redis.host=192.168.31.121
redis.port=6379
redis.password=password
redis.timeout=3000

spring-data-redis xml 配置文件 redis-context.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
     id = "poolConfig" class= "redis.clients.jedis.JedisPoolConfig" >
         "maxIdle" value= "${redis.maxIdle}" />
         "maxWaitMillis" value= "${redis.maxWait}" />
         "testOnBorrow" value= "${redis.testOnBorrow}" />
     < /bean >
    
     id = "connectionFactory"  class= "org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
         "poolConfig" ref= "poolConfig" />
         "port" value= "${redis.port}" />
         "hostName" value= "${redis.host}" />
        
         "timeout" value= "${redis.timeout}" >< /property >
         "database" value= "1" >< /property >
     < /bean >
 
     id = "commonRedisTemplate" class= "org.springframework.data.redis.core.RedisTemplate" >
         "connectionFactory" ref= "connectionFactory" />
         "keySerializer" ref= "stringRedisSerializer" />
         "hashKeySerializer" ref= "stringRedisSerializer" />
         "valueSerializer" ref= "stringRedisSerializer" />
         "hashValueSerializer" ref= "stringRedisSerializer" />
     < /bean >
 
     id = "connectionFactory1"  class= "org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
         "poolConfig" ref= "poolConfig" />
         "port" value= "${redis.port}" />
         "hostName" value= "${redis.host}" />
        
         "timeout" value= "${redis.timeout}" >< /property >
         "database" value= "2" >< /property >
     < /bean >
 
     id = "stringRedisSerializer" class= "org.springframework.data.redis.serializer.StringRedisSerializer" />
     id = "cacheRedisTemplate" class= "org.springframework.data.redis.core.RedisTemplate" >
         "connectionFactory" ref= "connectionFactory1" />
         "keySerializer" ref= "stringRedisSerializer" />
         "hashKeySerializer" ref= "stringRedisSerializer" />
         "valueSerializer" ref= "stringRedisSerializer" />
         "hashValueSerializer" ref= "stringRedisSerializer" />
     < /bean >

之后在 spring 配置文件中引用以上文件：

1
< import resource= "redis-context.xml" />　　

解释一下上面的配置：

poolConfig 即配置 redis 连接池，之后配置了两个 JedisConnectionFactory 和 RedisTemplate ，一个 RedisTemplate 对应一个 JedisConnectionFactory ，这样可以配置根据场景配置不同的 Redis 连接，比如超时时间要求不一致、database 0-15 可以存储不同的数据等。这里就配置了database 1 和 2 ，调用 commonRedisTemplate 会存到 database1 ，调用 cacheRedisTemplate 会存到 database2。

之后在 Service 层即可注入并引用这两个 RedisTemplate ，如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import org.apache.commons.lang3.StringUtils;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
 
import javax.annotation.Resource;
import java.io.*;
 
@Repository
public class RedisCache {
　　
     @Resource (name = "cacheRedisTemplate" )
     private RedisTemplate cacheRedisTemplate;
 
     public void put(Object key, Object value) {
         if ( null == value) {
             return ;
         }
 
         if (value instanceof String) {
             if (StringUtils.isEmpty(value.toString())) {
                 return ;
             }
         }
 
         // TODO Auto-generated method stub
         final String keyf = key + "" ;
         final Object valuef = value;
         final long liveTime = 86400 ;
 
         cacheRedisTemplate.execute( new RedisCallback() {
             public Long doInRedis(RedisConnection connection)
                     throws DataAccessException {
                 byte [] keyb = keyf.getBytes();
                 byte [] valueb = toByteArray(valuef);
                 connection.set(keyb, valueb);
                 if (liveTime > 0 ) {
                     connection.expire(keyb, liveTime);
                 }
                 return 1L;
             }
         });
     }
 
     public Object get(Object key) {
         final String keyf = (String) key;
         Object object;
         object = cacheRedisTemplate.execute( new RedisCallback() {
             public Object doInRedis(RedisConnection connection)
                     throws DataAccessException {
 
                 byte [] key = keyf.getBytes();
                 byte [] value = connection.get(key);
                 if (value == null ) {
                     return null ;
                 }
                 return toObject(value);
 
             }
         });
 
         return object;
     }
 
     /**
      * 描述 : .
      *

      * <使用方法说明>
      *

      *
      * @param bytes
      * @return
      */
     private Object toObject( byte [] bytes) {
         Object obj = null ;
         try {
             ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
             ObjectInputStream ois = new ObjectInputStream(bis);
             obj = ois.readObject();
             ois.close();
             bis.close();
         } catch (IOException ex) {
             ex.printStackTrace();
         } catch (ClassNotFoundException ex) {
             ex.printStackTrace();
         }
         return obj;
     }
 
     private byte [] toByteArray(Object obj) {
         byte [] bytes = null ;
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         try {
             ObjectOutputStream oos = new ObjectOutputStream(bos);
             oos.writeObject(obj);
             oos.flush();
             bytes = bos.toByteArray();
             oos.close();
             bos.close();
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return bytes;
     }
}

最后在 Controller 中调用即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Autowired
private RedisCache redisCache;
 
 
@RequestMapping (value = "get" , method = RequestMethod.GET)
@ResponseBody
public Object getByMyService(String key) {
     try {
         String result = redisService.get(key);
         return result;
     } catch (Exception e) {
         e.printStackTrace();
     }
     return null ;
}
 
@RequestMapping (value = "save" , method = RequestMethod.GET)
@ResponseBody
public Object save() {
     Token token = new Token();
     token.setAccess_token( "token" );
     token.setExpires_in( 1000 );
     try {
         redisCache.put( "token" , token);
     } catch (Exception e) {
         e.printStackTrace();
     }
     return "ok" ;
}　　

操作 Redis 集群

只用 Jedis 自己实现注入（区别于下面的引用spring-data-redis）

把前面的 JedisClusterClient 代码拿过来引用即可，只需实现一个访问 Redis 的 Service ，就可以集成到 Spring mvc 。Service 代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import org.springframework.stereotype.Service;
import util.JedisClusterClient;
 
/**
  * Created by fengdezitai on 2016/10/13.
  */
@Service
public class RedisClusterService {
 
     public void save() throws Exception{
         //调用 JedisClusterClient 中的方法
         JedisClusterClient jedisClusterClient = JedisClusterClient.getInstance();
         try {
             jedisClusterClient.SaveRedisCluster();
         } catch (Exception e){
             throw e;
         }
     }
}

最后在 Controller 中调用实现的 Service 即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Controller
@RequestMapping (value = "redisCluster" )
public class RedisClusterController {
 
     @Autowired
     private RedisClusterService redisClusterService;
 
     @RequestMapping (value = "save" ,method = RequestMethod.GET)
     @ResponseBody
     public Object save(){
         try {
             redisClusterService.save();
         } catch (Exception e){
             e.printStackTrace();
             return String.format( "error: %s" ,e.getMessage());
         }
         return "ok" ;
     }
}　　

用 spring-data-redis 包做集成 

Spring 和 spring-data-redis maven 包引用和前面一致，之所以引用 spring-data-redis 1.7.2.RELEASE，是因为目前只有这个最新版本才支持集群操作。

redis 集群服务属性配置

1
2
3
4
redis.maxIdle=300
redis.maxWait=3000
redis.testOnBorrow= false
redis.timeout=3000

spring-data-redis xml 集群配置文件 redis-cluster-context.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
     id = "poolConfig" class= "redis.clients.jedis.JedisPoolConfig" >
         "maxIdle" value= "${redis.maxIdle}" />
         "maxWaitMillis" value= "${redis.maxWait}" />
         "testOnBorrow" value= "${redis.testOnBorrow}" />
     < /bean >
 
 
     id = "redisClusterConfig" class= "org.springframework.data.redis.connection.RedisClusterConfiguration" >
         "maxRedirects" value= "3" >< /property >
         "clusterNodes" >
             < set >
                 "org.springframework.data.redis.connection.RedisNode" >
                     "host" value= "192.168.31.245" >< /constructor-arg >
                     "port" value= "7000" >< /constructor-arg >
                 < /bean >
                 "org.springframework.data.redis.connection.RedisNode" >
                     "host" value= "192.168.31.245" >< /constructor-arg >
                     "port" value= "7001" >< /constructor-arg >
                 < /bean >
                 "org.springframework.data.redis.connection.RedisNode" >
                     "host" value= "192.168.31.245" >< /constructor-arg >
                     "port" value= "7002" >< /constructor-arg >
                 < /bean >
                  "org.springframework.data.redis.connection.RedisNode" >
                     "host" value= "192.168.31.210" >< /constructor-arg >
                     "port" value= "7003" >< /constructor-arg >
                 < /bean >
                 "org.springframework.data.redis.connection.RedisNode" >
                     "host" value= "192.168.31.210" >< /constructor-arg >
                     "port" value= "7004" >< /constructor-arg >
                 < /bean >
                 "org.springframework.data.redis.connection.RedisNode" >
                     "host" value= "192.168.31.210" >< /constructor-arg >
                     "port" value= "7005" >< /constructor-arg >
                 < /bean >
             < /set >
         < /property >
     < /bean >
 
     id = "redis4CacheConnectionFactory"
           class= "org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
         "clusterConfig" ref= "redisClusterConfig" />
         "timeout" value= "${redis.timeout}" />
         "poolConfig" ref= "poolConfig" />
     < /bean >
 
 
     "stringRedisSerializer" class= "org.springframework.data.redis.serializer.StringRedisSerializer" />
     id = "clusterRedisTemplate" class= "org.springframework.data.redis.core.RedisTemplate" >
         "connectionFactory" ref= "redis4CacheConnectionFactory" />
         "keySerializer" ref= "stringRedisSerializer" />
         "hashKeySerializer" ref= "stringRedisSerializer" />
         "valueSerializer" ref= "stringRedisSerializer" />
         "hashValueSerializer" ref= "stringRedisSerializer" />
     < /bean >

之后在 Spring 配置文件中引用

1
< import resource= "redis-cluster-context.xml" />

解释以上配置：

poolConfig是连接池配置，redisClusterConfig 配置了 Redis 集群的各个节点（节点 host 和 port 最好写在属性配置文件中），集群搭建可见 我的 另一篇博客 。然后下面和单机配置一样了，一对 JedisConnectionFactory 和 RedisTemplate 。

之后在 Service 层即可注入并引用这个 RedisTemplate，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
 
import java.io.*;
 
/**
  * Created by fengdezitai on 2016/9/29.
  */
@Repository
public class RedisClusterCache {
 
     @Autowired
     private RedisTemplate clusterRedisTemplate;
 
 
     public void put(Object key, Object value) {
         if ( null == value) {
             return ;
         }
 
         if (value instanceof String) {
             if (StringUtils.isEmpty(value.toString())) {
                 return ;
             }
         }
 
         // TODO Auto-generated method stub
         final String keyf = key + "" ;
         final Object valuef = value;
         final long liveTime = 86400 ;
 
         clusterRedisTemplate.execute( new RedisCallback() {
             public Long doInRedis(RedisConnection connection)
                     throws DataAccessException {
                 byte [] keyb = keyf.getBytes();
                 byte [] valueb = toByteArray(valuef);
                 connection.set(keyb, valueb);
                 if (liveTime > 0 ) {
                     connection.expire(keyb, liveTime);
                 }
                 return 1L;
             }
         });
     }
 
     public Object get(Object key) {
         final String keyf = (String) key;
         Object object;
         object = clusterRedisTemplate.execute( new RedisCallback() {
             public Object doInRedis(RedisConnection connection)
                     throws DataAccessException {
 
                 byte [] key = keyf.getBytes();
                 byte [] value = connection.get(key);
                 if (value == null ) {
                     return null ;
                 }
                 return toObject(value);
 
             }
         });
 
         return object;
     }
 
     /**
      * 描述 : .
      *

      * <使用方法说明>
      *

      *
      * @param bytes
      * @return
      */
     private Object toObject( byte [] bytes) {
         Object obj = null ;
         try {
             ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
             ObjectInputStream ois = new ObjectInputStream(bis);
             obj = ois.readObject();
             ois.close();
             bis.close();
         } catch (IOException ex) {
             ex.printStackTrace();
         } catch (ClassNotFoundException ex) {
             ex.printStackTrace();
         }
         return obj;
     }
 
     private byte [] toByteArray(Object obj) {
         byte [] bytes = null ;
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         try {
             ObjectOutputStream oos = new ObjectOutputStream(bos);
             oos.writeObject(obj);
             oos.flush();
             bytes = bos.toByteArray();
             oos.close();
             bos.close();
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return bytes;
     }
}

最后在 Controller 中调用即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Controller
@RequestMapping (value = "redisCluster" )
public class RedisClusterController {
 
     @Autowired
     private RedisClusterCache redisClusterCache;
 
     @RequestMapping (value = "clusterSave" ,method = {RequestMethod.GET,RequestMethod.POST})
     @ResponseBody
     public Object clusterSave(){
         //redisClusterCache.put("cluster","save cluster");
         Token token = new Token();
         token.setExpires_in( 1000 );
         token.setAccess_token( "hello world" );
         redisClusterCache.put( "token" ,token);
         return "ok" ;
     }
 
     @RequestMapping (value = "getKey" ,method = RequestMethod.GET)
     @ResponseBody
     public Object getCluster(String key){
         Object val = redisClusterCache.get(key);
         return val;
     }
}　

注意事项：

  • 版本问题，如果用 spring-data-redis 做集成操作 Reids 集群，只有 spring-data-redis 目前最新版本1.7才包含对集群的操作，而最新的 spring-data-redis 中的某些功能对 Spring mvc 的版本也有些限制，所以尽量选择高版本的 Spring mvc 对应。
  • 如果存储的value值是一个实体对象，那么一定要实现 Serializable 接口

你可能感兴趣的:(Spring)

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java开发语言
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
  • spring mvc @RequestBody String类型参数 zoyation spring-mvcspringmvc
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
  • Java -jar 如何在后台运行项目 vincent_hahaha
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
  • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架 叶准鑫Natalie
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台 网顺技术团队 成品程序项目javavue.js汽车课程设计springboot
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
  • 分布式锁和spring事务管理 暴躁的鱼 锁及事务分布式springjava
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
  • Java面试笔记记录6 今天背八股了吗 java面试笔记
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
  • Sentinel 眼泪落在琴弦 springcloudjavajava
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
  • Spring @Async 深度解读：默认线程池执行器的配置与优化 小码快撩 springjava前端
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
  • Sentinel实时监控不展示问题 朱杰jjj sentinelsentinel
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？ 这孩子叫逆 Mybatis笔记mybatis数据库
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算 码踏云端 springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
  • Spring Security静态资源过滤（11） 小黑屋说YYDS spring
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
  • Spring Security定义多个过滤器链（10） 小黑屋说YYDS spring
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
  • java 技术 架构 相关文档 圣心 java架构开发语言
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
  • SpringSecurity初学总结 weixin_66442229 spring
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式 花儿街参考
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
  • SpringBoot 设置传入参数非必要 loveLifeLoveCoding springbootspringbootjavaspring
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
  • SpringBoot 获取 ApplicationContext loveLifeLoveCoding springbootspringbootjavaspring
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
  • java打印标签（机型TOSHIBA条码打印机B-EX4T）  嘘  JAVAjava
    java打印标签实现方式标签效果代码获取更多相关资料实现rfid写入功能实现方式打印机设置网络ipjava获取socket连接，调用TPCL指令标签效果代码packageorg.jeecg.modules.invinfo.util;importorg.jeecg.modules.invinfo.vo.BatKcInventoryDetailVo;importorg.springframework.
  • redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSourceexpire/delincr/lpush数据库分区redis
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷）   1、关于JedisPool.returnSource(Jedis jeids)   这个方法是从red
  • SQL性能优化-持续更新中。。。。。。 atongyeye oraclesql
    1 通过ROWID访问表--索引 你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
         如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
  • lvs- real 男人50 LVS
    #!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #.  /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
  • 生成公钥和私钥 oloz DSA安全加密
    package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
  • UIView 中加入的cocos2d，背景透明 374016526 cocos2dglClearColor
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
  • mysql常用命令 香水浓 mysql
    连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
  • 我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScriptjquerycsshtml5
    系统层面： 高可用性 所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
  • 利用ant进行远程tomcat部署 aijuans tomcat
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
  • 获取复利总收入 baalwolf 获取
           public static void main(String args[]){         int money=200;         int year=1;         double rate=0.1; &
  • eclipse.ini解释 BigBird2012 eclipse
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
  • AngularJS实现分页功能 bijian1013 JavaScriptAngularJS分页
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。   &nbs
  • [Maven学习笔记三]Maven archetype bit1129 ArcheType
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等.   mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式，   mvn archetype   1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
  • 【Java命令三】jps bit1129 Java命令
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看   [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
  • ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
  • unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学unity教程unity视频unity资料unity
    unity 3d还是cocos2dx哪个适合游戏？ 问：unity 3d还是cocos2dx哪个适合游戏？ 答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java算法面试百度招聘
    import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
  • 获取checkbox复选框的值 chiangfai checkbox
    <title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
  • MySQLdb用户指南 chenchao051 mysqldb
    原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
  • HIVE 窗口及分析函数 daizj hive窗口函数分析函数
    窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询 一、分析函数 用于等级、百分点、n分片等。 函数             说明 RANK()     &nbs
  • PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHPzip
    PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
  • 精彩英语贺词 dcj3sjt126com 英语
    I'm always here              我会一直在这里支持你                &nb
  • 基于Java注解的Spring的IoC功能 e200702084 javaspringbeanIOCOffice
                                      
  • java模拟post请求 geeksun java
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。 此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
  • Swift语法之 ---- ?和!区别 hongtoushizi ?swift!
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html   Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
  • centos7安装jdk1.7 jisonami jdkcentos
    安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量 在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
  • 数据源架构模式之数据映射器 home198979 PHP架构数据映射器datamapper
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。   一、概念 数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
  • 在Python中使用MYSQL pda158 mysqlpython
    缘由 　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 数据库中。 　　了解到 Python在这方面有优势，便选用之。 　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 记录一下，大家共勉。 　　 python中mysql的调用 　　 百度之后能够通过MySQLdb进行数据库操作。
  • 单例模式 hxl1988_0311 java单例设计模式单件
    package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
  • 27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他