背景分析

在考虑详细设计之前，我们先意淫一下秒杀场景，挖掘出场景具备的一些特性：

➟系统、数据场景特性

1、读多写少：秒杀场景中有效操作远远小于无效操作，所谓的无效操作即是访问了秒杀场景中的相关内容，却最终没有促成交易的操作。
2、顺时流量爆增导致了系统响应慢，甚至影响到其他业务功能。
3、秒杀的“量”因为抢的人多而导致超“量”被抢的情况。

➟用户行为特性

1、作为具有中国特色的中国大妈，在秒杀抢商品的捉急心态下，由于服务器压力大，响应比平时慢，她怎么能停止不断点提交的操作，直到页面有反馈呢？别说大妈了，就是知道原理的我们，有时候也管不住自己的手，不停的点点点下单，抢不抢得到是后话，先点爽了再说。
2、有票的江湖就有“黄牛党”，作为一个票务秒杀，如果缺少了“黄牛党”的存在就好像少了点什么。“黄牛党”往往使用软件、脚本进行自动抢票，软件通过封装场景相关数据包进行模拟正常用户操作行为下单。所以它不仅不依赖前端页面式的交互，同时还能在很短的时间内发起大量线程模拟下单数据包提交。

系统层面的分析

一个简单的系统包含了这些分层：1、页面层→站点层→控制层→服务层→数据库层。而复杂的系统中控制层可能还包括网关、服务中心以及复杂的服务层和其他组件等。可是无论什么结构，性能的瓶颈都在数据库层。所以减少数据库层的操作是整个场景实现的核心问题，而为了减轻服务器压力以及对其他业务的影响，我们尽量将无效流量拦截在上层，同时尽可能的减少每一层的性能消耗。

逐层分流

根据以上的分析，我们来看看每一层我们能做点什么来减轻下层的流量。

1、页面层

页面层是正常用户（非黄牛党）访问的入口，还记得在用户行为特性中出现的“点点点”场景吗？没错，这个场景会使得我们的无效流量进一步增加，特别是服务器压力越大响应越慢的时候无效流量反而增加的越多。而要解决这个问题也很容易，在页面层增加一些JS代码来控制一定时间内或者本次提交响应完成前的多次提交就可以。简单轻松有效，一小段JS代码在服务器响应慢的时候，也许就能减少几倍的无效流量。由于实现很简单，这里就不贴出代码了。

2、站点层

一个请求过来时，由站点层首先处理。分析一下请求包含的内容，不难发现除了有动态资源（需要从后台读取数据而生成的资源）也有静态资源（CSS,JS,图片固化资源等）。而如果都由一个服务器统一响应，无疑会增加该服务器的压力，特别是一个功能简单的页面静态资源占比可能不比动态资源少。所以分离静态资源会成为服务器减压的一种好方式，分离的方式常用的包含两种：
一种是常用的页面缓存。通过静态资源的本地化缓存，减少重复访问页面时静态文件的服务端获取。
而项目中如果使用了apache、nginx等，则可以用它们对静态文件做分离。
除此之外，站点层还可以玩其他花样来进一步减轻流量：
如静态资源太大时，可以使用压缩技术减少高并发下的网络IO。
如果静态资源太多时，可以使用静态资源打包方式减少页面的请求量。
对于用户基数大的系统时，还可以采取CDN流量分流等方法减轻请求的集中化和响应慢问题。
对于“黄牛党”，这里也能做到部分场景下的限流。比如通过nginx扩展自定义插件的方式，可以限制某IP或者某USER_ID访问同一网页的频率。不过这种方式仅仅能解决一些初级“黄牛党”，专业点的“黄牛党”都会有自己的IP代理池以及多个账号来绕过这样的限制。
当使用apache、nginx作为代理时，还可以结合他们提供的负载均衡功能来对内部访问负荷量进行优化。
对于大型系统来说，可能还有软件层面的网关，也可以做一些策略优化访问，起到减压服务器的作用。

3、服务层

1、核心实现：
服务层首先要保证数据的正确性，既不超库存，或者抢红包场景不能超过红包总额等。这里有两种思路的方案：
（1）并发量不大情况下的简单粗暴的数据库乐观锁：
update product set amout = amout - #amout where id = #id and amout - #amout >=0;
这样的写法是使用了数据库自身提供的乐观锁机制，在amout修改过程中不小于0由数据库保证。这个方法的优点是简单，可靠性最强（因为是数据库保障其可靠性）。缺点也很明显，并发量有限。一般来说性能好点的服务器中，如果是高速机械硬盘可以达到300左右的最大数据库并发量，固态硬盘则达到700左右。
（2）高并发分布式乐观锁机制（CAS机制check and set）：
当并发量大大超过数据库极限时，就需要引用分布式缓存的方式来解决。常用的缓存有memcached和Redis等。如果仅仅从秒杀的场景来说，memcached比Redis更合适主要是因为：
A、单纯从秒杀场景memcache更合适，因为它的模型是多线程，更合适高并发写的场景。redis的模型是单线程，边读边写在并发量大的时候会相对慢一些。
B、memcache自带CAS光环，有相关函数直接调用；redis虽然也有办法实现，但是还是需要自己实现。
整体方案图：https://www.processon.com/view/5a2e0435e4b0d8b7bf78d9f2
cas原理图：

image.png

实现代码：

package com.my.miaosa.service.impl;

import java.util.List;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.my.miaosa.entity.dto.FastBuyBusinessDTO;
import com.my.miaosa.entity.dto.Order;
import com.my.miaosa.service.FastBuyService;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

@Service
public class FastBuyServiceImpl implements FastBuyService {
    private static Logger logger = LoggerFactory.getLogger("");

    /**
     * 
     * @param jedis 第一道过滤流量分离的redis主要用于场景隔离，不影响其他业务，如不需要隔离可以和jedisMain是同一个实例
     * @param jedisMain 主要业务redis实例
     * @param fastBuyBusinessDTO 秒杀场景商品基础信息封装类
     * @param orderUserName 关联下单用户名（或ID）
     * @param orders 本商品下单数量
     * @return
     */
    public String fastBuyProductOrders(Jedis jedis,Jedis jedisMain,FastBuyBusinessDTO fastBuyBusinessDTO, String orderUserName,int orders) {
        //过滤部分恶意脚本，不从redis中获取数据直接和初始化数据判断，redis减轻压力，预防部分恶意刷单。
        //伪判断预防一些恶意脚本
        if (!this.allowProductAmout(fastBuyBusinessDTO.getMaxAmout(), orders)) {
            return "抢购商品不足，抢购失败！";
        }
        
        //判断下单是否超库存，从redis中获取当前库存
        if(!this.allowFastBuyProduc(fastBuyBusinessDTO.getProductAmoutId(), orders, jedis)) {
            return "抢购商品不足，抢购失败！";
        }
        
        return this.fastBuyProduct(jedisMain, fastBuyBusinessDTO.getProductAmoutId(), fastBuyBusinessDTO.getOrderListId(), orderUserName, orders, fastBuyBusinessDTO.getProductId());
        
        
    }
    
    /**
     * 初步判断下单量是否超出剩余量
     * return 超
     */
    public boolean allowFastBuyProduc(String productAmoutId,int orders,Jedis jedis) {
        
        //一阶段过滤流量、尽可能不写REDIS，提高性能
        //判断是否还有库存
        //预拿一次，如果剩余商品已经<=0，直接返回结果过滤流量
        int prdNum = Integer.parseInt(jedis.get(productAmoutId));
        
        //判断所下的单数量是否在剩余范围内
        return this.allowProductAmout(prdNum, orders);
    }
    
    /**
     * 
     * @param jedis
     * @param amoutId redis中的存本次活动商品总量的KEY
     * @param ordersId redis中存本次活动商品抢购成功的用户信息队列的KEY
     * @param orders 下单数量
     * @param orderUserName 购买人
     * @param productId 商品标识唯一ID
     * @return
     */
    public String fastBuyProduct(Jedis jedis, String amoutId,String ordersId, String orderUserName,int orders,String productId){
        String result = "抢商品失败咯！";
        if (logger.isInfoEnabled()) {
            logger.info(orderUserName + "开始抢票-" + orders + " 张！！");
        }
        
        //TODO 根据实际业务和测试情况，可以用for限制重试抢票次数
        while (true) {
            int i = 0; i++;
            if (logger.isInfoEnabled()) {
                logger.info(orderUserName + "---第" + i + "次抢票");
            }
            try {
                jedis.watch(amoutId,ordersId);// 监视key ，如果在以下事务执行之前key的值被其他命令所改动，那么事务将被打断
                int prdNum = Integer.parseInt(jedis.get(amoutId));
                if (this.allowProductAmout(prdNum, orders)) {
                    //TODO 1、商品规则是否满足根据实际情况加
                    //TODO 2、分析用户规则根据实际情况加
                    
                    Transaction transaction = jedis.multi();
                    transaction.set(amoutId, String.valueOf(prdNum - orders));//如果可以一次购买多张需要修改，对应下面的抢购成功的用户入队列也需要修改。
                    // 把当前抢到商品的用户记录到下单队列中，sadd不允许插入重复内容。读队列smembers，读的时候不会出队列，不会改变队列内容，所以不影响CAS中的写入。获取长度scard
                    //封装成JSON格式后提交队列
                    transaction.sadd(ordersId, this.createOrdersString(orderUserName, productId, orders));
                    List<Object> res = transaction.exec();

                    // 事务提交后如果为null，说明key值在本次事务提交前已经被改变，本次事务不执行。
                    if (res == null || res.isEmpty()) {
                        if (logger.isInfoEnabled()) {
                            logger.info( orderUserName + "---第" + i  + "次抢-----没有抢到商品，正在重试");
                        }
                    } else {
                        result = "抢购成功！";
                        if (logger.isInfoEnabled()) {
                            logger.info( orderUserName + "---第" + i  + "次抢-----抢到商品-");
                        }
                        break;
                    }
                    
                } else {
                    result = "库存为0，本商品已经被抢空了哦，欢迎下次光临88";
                    break;
                }
            } catch (Exception e) {
                logger.error("抢购出错：" + e);
            } finally {
                jedis.unwatch();
                
            }
        }
        
        return result;
    }
    
    
    /**
     * 是否在库存范围内
     * @return 范围内true、范围外false
     */
    private boolean allowProductAmout(int prdNum,int orders) {
        
        //商品已经没有库存
        if (prdNum <= 0) {return false;}
        //商品当前库存不够支付订单量
        if (prdNum - orders < 0) {return false;}
        
        return true;
    }
    
    /**
     * 转JSON格式
     * @param orderUserName
     * @param productId
     * @param orderCount
     * @return
     */
    public String[] createOrdersString (String orderUserName,String productId,int orderCount) {
        String[] result = new String[orderCount];
        for (int i = 0; i < result.length; i++) {
            result[i] = JSON.toJSONString(new Order(orderUserName,productId,UUID.randomUUID().toString()));
        }
        
        return result;
    }
}

package com.my.miaosa.entity.dto;

import java.io.Serializable;

public class FastBuyBusinessDTO implements Serializable {
    
    private String id;//

    private String productId;//商品主键

    private String productAmoutId;//商品剩余量ID   String
    
    private String orderListId;//关联的下订成功客户列表（缓存中的） 集合
    
    
    //扩展规则时候用的，暂时没用
    private int maxTransaction; //本次抢购同一用户最多可以购买几个的上限值
    
    private int maxTransactionNumber;//同一用户一次最多可以抢购几个商品
    
    private int maxRepeatBuy;//同一用户是否可以重复购买，如果否则为0.如果可以则大于0，表示可以重复参与本次抢购多少次。如单个用户可以参与本次抢购3次，则这里为3
    
    private int maxAmout;//最大购买量，既本次活动本商品总量

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public String getProductAmoutId() {
        return productAmoutId;
    }

    public void setProductAmoutId(String productAmoutId) {
        this.productAmoutId = productAmoutId;
    }

    public String getOrderListId() {
        return orderListId;
    }

    public void setOrderListId(String orderListId) {
        this.orderListId = orderListId;
    }

    public int getMaxTransaction() {
        return maxTransaction;
    }

    public void setMaxTransaction(int maxTransaction) {
        this.maxTransaction = maxTransaction;
    }

    public int getMaxTransactionNumber() {
        return maxTransactionNumber;
    }

    public void setMaxTransactionNumber(int maxTransactionNumber) {
        this.maxTransactionNumber = maxTransactionNumber;
    }

    public int getMaxRepeatBuy() {
        return maxRepeatBuy;
    }

    public void setMaxRepeatBuy(int maxRepeatBuy) {
        this.maxRepeatBuy = maxRepeatBuy;
    }

    public int getMaxAmout() {
        return maxAmout;
    }

    public void setMaxAmout(int maxAmout) {
        this.maxAmout = maxAmout;
    }
}

package com.my.miaosa.entity.dto;

import java.text.SimpleDateFormat;

/**
 * 尽量简短，减少redis读写压力
 * @ClassName Order
 * @Description 
 * @author Administrator
 * @date 2017年12月12日 下午2:05:40
 * @version
 *
 */
public class Order {

    private String oun;//orderUserName下单用户名（或ID）
    
    private String opn;//orderProductName下单产品名（或ID）

    private String time;
    
    /**
     * 注意，本ID在本次抢购中必须是唯一ID，不然可能出现最终的下单记录总数和已被下单产品数量不一致（记录的下单量小于出库商品总量）。
     */
    private String id;//本ID只有在生成订单号时起作用，主要是为了区分一次下多个单导致的数据内容一致，从而使得sadd覆盖少订单问题，不使用UUID减轻网络和缓冲IO，使用时间戳有精度不够，容易重复
    
    //必须要有空的构造函数，否则fastjson转换报错
    public Order() {
        
    }
    
    public Order(String orderUserName,String orderProductName,String currectId) {
        this.oun = orderUserName;
        this.opn = orderProductName;
        this.id = currectId;
        this.time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date());
    }
    
    public String getOun() {
        return oun;
    }

    public void setOun(String oun) {
        this.oun = oun;
    }

    public String getOpn() {
        return opn;
    }

    public void setOpn(String opn) {
        this.opn = opn;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }   
}

测试类：

package com.my.miaosa.test;

import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.CountDownLatch;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.test.context.ContextConfiguration;

import com.alibaba.fastjson.JSON;
import com.my.miaosa.entity.dto.FastBuyBusinessDTO;
import com.my.miaosa.entity.dto.Order;
import com.my.miaosa.service.FastBuyService;
import com.my.miaosa.service.impl.FastBuyServiceImpl;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@ContextConfiguration("classpath:applicationContext.xml")
public class FastBuyTest {
    
    private static Jedis jedis1;
    private static Jedis jedis2;
    private static JedisPool pool;
    private static JedisPoolConfig config;
    
    //业务数据设置
    private static FastBuyBusinessDTO fastBuyBusinessDTO;
    private final static int MAX_AMOUT = 10;//本次活动总商品量
    
    //测试线程数据设置
    private static CountDownLatch latch;
    //初始化几个线程等待抢商品
    private final static int THREAD_LENG = 200;
    
    @Before
    public void init() {
        initRedisPool();//初始化redis数据
        fastBuyBusinessDTO = new FastBuyBusinessDTO();
        initFastBuy();//初始化业务数据
        
    }
    
    @After
    public void colseResources() {
        jedis1.close();
        pool.close();
    }
    
    /**
     * 模拟高并发场景（1秒内，1000的并发量）
     * @throws InterruptedException
     */
    @Test
    public void fastBuyProductTest() throws InterruptedException {
        System.out.println("开始产品量：" + jedis1.get(fastBuyBusinessDTO.getProductAmoutId()));
        System.out.println("开始订单量：" + jedis1.scard(fastBuyBusinessDTO.getOrderListId()));
        
        for(int i =0;i<THREAD_LENG + 1;i++){
            Thread.sleep(20L);
            String orderUserName = "orderUserName_" + i;//模拟高并发情况下，正常情况的多用户下单
//          String orderUserName = "orderUserName_" + "0";//模拟高并发情况下，单个用户多次下单（如黄牛党）
            int orders = 3;
            int ordersRandom =  (int)(1 + Math.random()*(4-1 + 1));
            Thread th = new Thread(new TestThread(pool,orderUserName,ordersRandom));
            th.setName("THREADDDDD_"+i);
            System.out.println(th.getName()+"inited...");
            th.start();
            latch.countDown();//业务调用完成，计数器减一
        }
        Thread.sleep(3000);
        
        //显示订单结果，并把订单结果转换成order对象
        if (true) {
            Set<String> orders = jedis1.smembers(fastBuyBusinessDTO.getOrderListId());
            
            Iterator<String> it = orders.iterator();  
            while (it.hasNext()) {
              Order order = (Order)JSON.parseObject(it.next(), Order.class);
              System.out.println("userid:" + order.getOun() + "-----productId:" + order.getOpn()  + "------orderTime:" + order.getTime() );
            }
        }
        
        System.out.println("内存剩余产品：" + jedis1.get(fastBuyBusinessDTO.getProductAmoutId()));
        System.out.println("内存订单量：" + jedis1.scard(fastBuyBusinessDTO.getOrderListId()));
    }
    
    /**
     * 初始抢购
     */
    public static void initFastBuy() {
        fastBuyBusinessDTO.setId("1");
        fastBuyBusinessDTO.setProductAmoutId("product_amout_id_1");
        fastBuyBusinessDTO.setProductId("product_id_1");
        fastBuyBusinessDTO.setOrderListId("order_list_id_1");
        fastBuyBusinessDTO.setMaxAmout(MAX_AMOUT);
        
        String key = fastBuyBusinessDTO.getProductAmoutId();
        String clientList = fastBuyBusinessDTO.getOrderListId();// 抢购到商品的顾客列表
        if (jedis1.exists(key)) {
            jedis1.del(key);
        }
        
        if (jedis1.exists(clientList)) {
            jedis1.del(clientList);
        }
        jedis1.set(key, String.valueOf(MAX_AMOUT));// 初始化
    }
    
    public static void initRedisPool() {
        jedis1 = new Jedis("127.0.0.1",6379);
        jedis2 = new Jedis("127.0.0.1",6379);
        //利用Redis连接池，保证多个线程利用多个连接，充分模拟并发性
        config = new JedisPoolConfig();
        config.setMaxIdle(10);
        config.setMaxWaitMillis(1000);
        config.setMaxTotal(THREAD_LENG + 1);
        pool = new JedisPool(config, "127.0.0.1", 6379);
        //利用ExecutorService 管理线程
//        service = Executors.newFixedThreadPool(THREAD_LENG);
        //CountDownLatch保证主线程在全部线程结束之后退出
        latch = new CountDownLatch(THREAD_LENG);
    }
    
    public static class TestThread implements Runnable {
        private Jedis cli;
        private JedisPool pool;
        private FastBuyService fs = new FastBuyServiceImpl();
        private String orderUserName;
        private int orders;
        
        public TestThread(JedisPool pool,String orderUserName,int orders) {
            cli = pool.getResource();
            this.pool = pool;
            this.orderUserName = orderUserName;
            this.orders = orders;
        }
        
        public TestThread(Jedis jedis,String orderUserName,int orders) {
            cli = jedis;
            this.orderUserName = orderUserName;
            this.orders = orders;
        }

        public void run() {
            try{
                latch.await();
                fs.fastBuyProductOrders(cli, cli, fastBuyBusinessDTO,orderUserName , orders);
            }catch(Exception e){
                pool.close();
            }
        }
    }
}

POM.XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.my</groupId>
    <artifactId>miaosa</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <dependencies>

        <!-- spring核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.3.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.3.RELEASE</version>
        </dependency>

        <!-- config jedis data and client jar -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.2</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.21</version>
        </dependency>

        <!-- 单元测试相关依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.2.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- 日志相关依赖 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.10</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.1.2</version>
        </dependency>

    </dependencies>


</project>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:c="http://www.springframework.org/schema/c"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:cache="http://www.springframework.org/schema/cache" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:redisson="http://redisson.org/schema/redisson"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context 
                        http://www.springframework.org/schema/context/spring-context-4.3.xsd
                        http://www.springframework.org/schema/cache
                        http://www.springframework.org/schema/cache/spring-cache.xsd
                        http://www.springframework.org/schema/tx 
                        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
                        http://redisson.org/schema/redisson
                        http://redisson.org/schema/redisson/redisson.xsd">

                        

    <context:property-placeholder location="classpath:db.properties"
        ignore-unresolvable="true" />

    
    <context:component-scan base-package="com.*">
    </context:component-scan>
    
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="100" />
        <property name="maxIdle" value="10" />
    </bean>

    <bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
        destroy-method="destroy">
        <property name="hostName" value="localhost" />
        <property name="port" value="6379" />
        <property name="database" value="2" />
        <property name="timeout" value="3000" />
        <property name="usePool" value="true" />
        <property name="poolConfig" ref="jedisPoolConfig" />
    </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="enableTransactionSupport" value="false"></property>
    </bean>
    
</beans>