基于rabbitmq延迟插件实现分布式延迟任务

目录
  • 一、延迟任务的使用场景
  • 二、组件安装
  • 三、RabbitMQ延迟队列插件的延迟队列实现
    • 1、基本原理
    • 2、核心组件开发走起

之前给大家介绍过SpringBoot集成Redisson实现延迟队列的场景分析,今天介绍下基于rabbitmq延迟插件rabbitmq_delayed_message_exchange实现延迟任务。

一、延迟任务的使用场景

1、下单成功,30分钟未支付。支付超时,自动取消订单

2、订单签收,签收后7天未进行评价。订单超时未评价,系统默认好评

3、下单成功,商家5分钟未接单,订单取消

4、配送超时,推送短信提醒

5、三天会员试用期,三天到期后准时准点通知用户,试用产品到期了

......

对于延时比较长的场景、实时性不高的场景,我们可以采用任务调度的方式定时轮询处理。如:xxl-job。

今天我们讲解延迟队列的实现方式,而延迟队列有很多种实现方式,普遍会采用如下等方式,如:

1.如基于RabbitMQ的队列ttl+死信路由策略:通过设置一个队列的超时未消费时间,配合死信路由策略,到达时间未消费后,回会将此消息路由到指定队列

2.基于RabbitMQ延迟队列插件(rabbitmq-delayed-message-exchange):发送消息时通过在请求头添加延时参数(headers.put("x-delay",5000))即可达到延迟队列的效果。(顺便说一句阿里云的收费版rabbitMQ当前可支持一天以内的延迟消息),局限性:目前该插件的当前设计并不真正适合包含大量延迟消息(例如数十万或数百万)的场景,详情参见#/issues/72另外该插件的一个可变性来源是依赖于 Erlang 计时器,在系统中使用了一定数量的长时间计时器之后,它们开始争用调度程序资源。

3.使用redis的zset有序性,轮询zset中的每个元素,到点后将内容迁移至待消费的队列,(redisson已有实现)

4.使用redis的key的过期通知策略,设置一个key的过期时间为延迟时间,过期后通知客户端(此方式依赖redis过期检查机制key多后延迟会比较严重;Redis的pubsub不会被持久化,服务器宕机就会被丢弃)。

二、组件安装

安装rabbitMQ需要依赖erlang语言环境,所以需要我们下载erlang的环境安装程序。网上有很多安装教程,这里不再贴图累述,需要注意的是:该延迟插件支持的版本匹配。

插件Git官方地址:https://github.com/rabbitmq/rabbitmq-delayed-message-exchange

当你成功安装好插件后运行起rabbitmq管理后台,在新建exchange里就可以看到type类型中多出了这个选项

三、RabbitMQ延迟队列插件的延迟队列实现

1、基本原理

  通过 x-delayed-message 声明的交换机,它的消息在发布之后不会立即进入队列,先将消息保存至 Mnesia(一个分布式数据库管理系统,适合于电信和其它需要持续运行和具备软实时特性的 Erlang 应用。目前资料介绍的不是很多)

  这个插件将会尝试确认消息是否过期,首先要确保消息的延迟范围是 Delay > 0, Delay =< ?ERL_MAX_T(在 Erlang 中可以被设置的范围为 (2^32)-1 毫秒),如果消息过期通过 x-delayed-type 类型标记的交换机投递至目标队列,整个消息的投递过程也就完成了。

2、核心组件开发走起

引入maven依赖

<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>

application.yml简单配置

 rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /

RabbitMqConfig配置文件

package com.example.code.bot_monomer.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.ExchangeBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
/**
 * @author: shf description: date: 2022/1/5 15:00
 */
@Configuration
public class RabbitMQConfig {
    /**
     * 普通
     */
    public static final String EXCHANGE_NAME = "test_exchange";
    public static final String QUEUE_NAME = "test001_queue";
    public static final String NEW_QUEUE_NAME = "test002_queue";
    /**
     * 延迟
     */
    public static final String DELAY_EXCHANGE_NAME = "delay_exchange";
    public static final String DELAY_QUEUE_NAME = "delay001_queue";
    public static final String DELAY_QUEUE_ROUT_KEY = "key001_delay";
    //由于阿里rabbitmq增加队列要额外收费,现改为各业务延迟任务共同使用一个queue:delay001_queue
    //public static final String NEW_DELAY_QUEUE_NAME = "delay002_queue";

    @Bean
    public CustomExchange delayMessageExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        //自定义交换机
        return new CustomExchange(DELAY_EXCHANGE_NAME, "x-delayed-message", true, false, args);
    }
    @Bean
    public Queue delayMessageQueue() {
        return new Queue(DELAY_QUEUE_NAME, true, false, false);
    }
    @Bean
    public Binding bindingDelayExchangeAndQueue(Queue delayMessageQueue, Exchange delayMessageExchange) {
        return new Binding(DELAY_QUEUE_NAME, Binding.DestinationType.QUEUE, DELAY_EXCHANGE_NAME, DELAY_QUEUE_ROUT_KEY, null);
        //return BindingBuilder.bind(delayMessageQueue).to(delayMessageExchange).with("key001_delay").noargs();
    }

    /**
     * 交换机
     */
    @Bean
    public Exchange orderExchange() {
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
        //return new TopicExchange(EXCHANGE_NAME, true, false);
    }
    /**
     * 队列
     */
    @Bean
    public Queue orderQueue() {
        //return QueueBuilder.durable(QUEUE_NAME).build();
        return new Queue(QUEUE_NAME, true, false, false, null);
    }
    /**
     * 队列
     */
    @Bean
    public Queue orderQueue1() {
        //return QueueBuilder.durable(NEW_QUEUE_NAME).build();
        return new Queue(NEW_QUEUE_NAME, true, false, false, null);
    }
    /**
     * 交换机和队列绑定关系
     */
    @Bean
    public Binding orderBinding(Queue orderQueue, Exchange orderExchange) {
        //return BindingBuilder.bind(queue).to(exchange).with("#.delay").noargs();
        return new Binding(QUEUE_NAME, Binding.DestinationType.QUEUE, EXCHANGE_NAME, "test001_common", null);
    }
    /**
     * 交换机和队列绑定关系
     */
    @Bean
    public Binding orderBinding1(Queue orderQueue1, Exchange orderExchange) {
        //return BindingBuilder.bind(queue).to(exchange).with("#.delay").noargs();
        return new Binding(NEW_QUEUE_NAME, Binding.DestinationType.QUEUE, EXCHANGE_NAME, "test001_common", null);
    }
}

MqDelayQueueEnum枚举类

package com.example.code.bot_monomer.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
 * @author: shf description: 延迟队列业务枚举类
 * date: 2021/8/27 14:03
 */
@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum MqDelayQueueEnum {
    /**
     * 业务0001
     */
    YW0001("yw0001", "测试0001", "yw0001"),
    /**
     * 业务0002
     */
    YW0002("yw0002", "测试0002", "yw0002");
    /**
     * 延迟队列业务区分唯一Key
     */
    private String code;
    /**
     * 中文描述
     */
    private String name;
    /**
     * 延迟队列具体业务实现的 Bean 可通过 Spring 的上下文获取
     */
    private String beanId;
    public static String getBeanIdByCode(String code) {
        for (MqDelayQueueEnum queueEnum : MqDelayQueueEnum.values()) {
            if (queueEnum.code.equals(code)) {
                return queueEnum.beanId;
            }
        }
        return null;
    }
}

模板接口处理类:MqDelayQueueHandle

package com.example.code.bot_monomer.service.mqDelayQueue;
/**
 * @author: shf description: RabbitMQ延迟队列方案处理接口
 * date: 2022/1/10 10:46
 */
public interface MqDelayQueueHandle<T> {
    void execute(T t);
}

具体业务实现处理类

@Slf4j
@Component("yw0001")
public class MqTaskHandle01 implements MqDelayQueueHandle<String> {
    @Override
    public void execute(String s) {
        log.info("MqTaskHandle01.param=[{}]",s);
        //TODO
    }
}

注意:@Component("yw0001") 要和业务枚举类MqDelayQueueEnum中对应的beanId保持一致。

统一消息体封装类

/**
 * @author: shf description: date: 2022/1/10 10:51
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class MqDelayMsg<T> {
    /**
     * 业务区分唯一key
     */
    @NonNull
    String businessCode;
    /**
     * 消息内容
     */
    @NonNull
    T content;
}

统一消费分发处理Consumer

package com.example.code.bot_monomer.service.mqConsumer;
import com.alibaba.fastjson.JSONObject;
import com.example.code.bot_monomer.config.common.MqDelayMsg;
import com.example.code.bot_monomer.enums.MqDelayQueueEnum;
import com.example.code.bot_monomer.service.mqDelayQueue.MqDelayQueueHandle;
import org.apache.commons.lang3.StringUtils;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
/**
 * @author: shf description: date: 2022/1/5 15:12
 */
@Slf4j
@Component
//@RabbitListener(queues = "test001_queue")
@RabbitListener(queues = "delay001_queue")
public class TestConsumer {
    @Autowired
    ApplicationContext context;
    /**
     * RabbitHandler 会自动匹配 消息类型(消息自动确认)
     *
     * @param msgStr
     * @param message
     */
    @RabbitHandler
    public void taskHandle(String msgStr, Message message) {
        try {
            MqDelayMsg msg = JSONObject.parseObject(msgStr, MqDelayMsg.class);
            log.info("TestConsumer.taskHandle:businessCode=[{}],deliveryTag=[{}]", msg.getBusinessCode(), message.getMessageProperties().getDeliveryTag());
            String beanId = MqDelayQueueEnum.getBeanIdByCode(msg.getBusinessCode());
            if (StringUtils.isNotBlank(beanId)) {
                MqDelayQueueHandle<Object> handle = (MqDelayQueueHandle<Object>) context.getBean(beanId);
                handle.execute(msg.getContent());
            } else {
                log.warn("TestConsumer.taskHandle:MQ延迟任务不存在的beanId,businessCode=[{}]", msg.getBusinessCode());
            }
        } catch (Exception e) {
            log.error("TestConsumer.taskHandle:MQ延迟任务Handle异常:", e);
        }
    }
}

最后简单封装个工具类

package com.example.code.bot_monomer.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.code.bot_monomer.config.RabbitMQConfig;
import com.example.code.bot_monomer.config.common.MqDelayMsg;
import org.apache.commons.lang3.StringUtils;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Objects;
import lombok.extern.slf4j.Slf4j;
/**
 * @author: shf description: MQ分布式延迟队列工具类 date: 2022/1/10 15:20
 */
@Slf4j
@Component
public class MqDelayQueueUtil {
    @Autowired
    private RabbitTemplate template;
    @Value("${mqdelaytask.limit.days:2}")
    private Integer mqDelayLimitDays;
    /**
     * 添加延迟任务
     *
     * @param bindId 业务绑定ID,用于关联具体消息
     * @param businessCode 业务区分唯一标识
     * @param content      消息内容
     * @param delayTime    设置的延迟时间 单位毫秒
     * @return 成功true;失败false
     */
    public boolean addDelayQueueTask(@NonNull String bindId, @NonNull String businessCode, @NonNull Object content, @NonNull Long delayTime) {
        log.info("MqDelayQueueUtil.addDelayQueueTask:bindId={},businessCode={},delayTime={},content={}", bindId, businessCode, delayTime, JSON.toJSONString(content));
        if (StringUtils.isAnyBlank(bindId, businessCode) || Objects.isNull(content) || Objects.isNull(delayTime)) {
            return false;
        }
        try {
            //TODO 延时时间大于2天的先加入数据库表记录,后由定时任务每天拉取2次将低于2天的延迟记录放入MQ中等待到期执行
            if (ChronoUnit.DAYS.between(LocalDateTime.now(), LocalDateTime.now().plus(delayTime, ChronoUnit.MILLIS)) >= mqDelayLimitDays) {
                //TODO
            } else {
                this.template.convertAndSend(
                    RabbitMQConfig.DELAY_EXCHANGE_NAME,
                    RabbitMQConfig.DELAY_QUEUE_ROUT_KEY,
                    JSONObject.toJSONString(MqDelayMsg.<Object>builder().businessCode(businessCode).content(content).build()),
                    message -> {
                        //注意这里时间可使用long类型,毫秒单位,设置header
                        message.getMessageProperties().setHeader("x-delay", delayTime);
                        return message;
                    }
                );
            }
        } catch (Exception e) {
            log.error("MqDelayQueueUtil.addDelayQueueTask:bindId={}businessCode={}异常:", bindId, businessCode, e);
            return false;
        }
        return true;
    }
    /**
     * 撤销延迟消息
     * @param bindId 业务绑定ID,用于关联具体消息
     * @param businessCode 业务区分唯一标识
     * @return 成功true;失败false
     */
    public boolean cancelDelayQueueTask(@NonNull String bindId, @NonNull String businessCode) {
        if (StringUtils.isAnyBlank(bindId,businessCode)) {
            return false;
        }
        try {
            //TODO 查询DB,如果消息还存在即可删除
        } catch (Exception e) {
            log.error("MqDelayQueueUtil.cancelDelayQueueTask:bindId={}businessCode={}异常:", bindId, businessCode, e);
            return false;
        }
        return true;
    }
    /**
     * 修改延迟消息
     * @param bindId 业务绑定ID,用于关联具体消息
     * @param businessCode 业务区分唯一标识
     * @param content      消息内容
     * @param delayTime    设置的延迟时间 单位毫秒
     * @return 成功true;失败false
     */
    public boolean updateDelayQueueTask(@NonNull String bindId, @NonNull String businessCode, @NonNull Object content, @NonNull Long delayTime) {
        if (StringUtils.isAnyBlank(bindId, businessCode) || Objects.isNull(content) || Objects.isNull(delayTime)) {
            return false;
        }
        try {
            //TODO 查询DB,消息不存在返回false,存在判断延迟时长入库或入mq
            //TODO 延时时间大于2天的先加入数据库表记录,后由定时任务每天拉取2次将低于2天的延迟记录放入MQ中等待到期执行
            if (ChronoUnit.DAYS.between(LocalDateTime.now(), LocalDateTime.now().plus(delayTime, ChronoUnit.MILLIS)) >= mqDelayLimitDays) {
                //TODO
            } else {
                this.template.convertAndSend(
                    RabbitMQConfig.DELAY_EXCHANGE_NAME,
                    RabbitMQConfig.DELAY_QUEUE_ROUT_KEY,
                    JSONObject.toJSONString(MqDelayMsg.<Object>builder().businessCode(businessCode).content(content).build()),
                    message -> {
                        //注意这里时间可使用long类型,毫秒单位,设置header
                        message.getMessageProperties().setHeader("x-delay", delayTime);
                        return message;
                    }
                );
            }
        } catch (Exception e) {
            log.error("MqDelayQueueUtil.updateDelayQueueTask:bindId={}businessCode={}异常:", bindId, businessCode, e);
            return false;
        }
        return true;
    }
}

附上测试类:

/**
 * description: 延迟队列测试
 *
 * @author: shf date: 2021/8/27 14:18
 */
@RestController
@RequestMapping("/mq")
@Slf4j
public class MqQueueController {
    @Autowired
    private MqDelayQueueUtil mqDelayUtil;
    @PostMapping("/addQueue")
    public String addQueue() {
        mqDelayUtil.addDelayQueueTask("00001",MqDelayQueueEnum.YW0001.getCode(),"delay0001测试",3000L);
        return "SUCCESS";
    }
}

贴下DB记录表的字段设置

配合xxl-job定时任务即可。

  由于投递后的消息无法修改,设置延迟消息需谨慎!并需要与业务方配合,如:延迟时间在2天以内(该时间天数可调整,你也可以设置阈值单位为小时,看业务需求)的消息不支持修改与撤销。2天之外的延迟消息支持撤销与修改,需要注意的是,需要绑定关联具体操作业务唯一标识ID以对应关联操作撤销或修改。(PS:延迟时间设置在2天以外的会先保存到DB记录表,由定时任务每天拉取到时2天内的投放到延迟对列)。

  再稳妥点,为了防止进入DB记录的消息有操作时间误差导致的不一致问题,可在消费统一Consumer消费分发前,查询DB记录表,该消息是否已被撤销删除(增加个删除标记字段记录),并且当前时间大于等于DB表中记录的到期执行时间才能分发出去执行,否则弃用。

此外,利用rabbitmq的死信队列机制也可以实现延迟任务,有时间再附上实现案例。

到此这篇关于基于rabbitmq延迟插件实现分布式延迟任务的文章就介绍到这了,更多相关rabbitmq分布式延迟任务内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Centos7.3 RabbitMQ分布式集群搭建示例

    本文介绍了Centos7.3 RabbitMQ分布式集群搭建示例,分享给大家,具体如下: 注意事项 centos 7.x 关闭firewall 三台机器: 172.17.250.97 rabbiMQ01 172.17.250.98 rabbiMQ03 172.17.250.99 rabbiMQ02 配置 hosts 172.17.250.97 fz-rabbitMQ01 172.17.250.99 fz-rabbitMQ02 172.17.250.98 fz-rabbitMQ03 $ syste

  • 关于利用RabbitMQ实现延迟任务的方法详解

    开发过程中通常会碰到这样的需求: 淘宝订单业务:下单后 30min 之内没有付款,就自动取消订单. 饿了吗订餐通知:下单成功后 60s 之后给用户发送短信通知. 关闭空闲连接:服务器中有很多客户端的连接,空闲一段时间之后需要关闭之. 缓存:缓存中的对象,超过了空闲时间,从缓存中移出. 任务超时处理:在网络协议滑动窗口请求应答式交互时,处理超时未响应的请求. 失败重试机制:业务操作失败后,间隔一定的时间进行失败重试. 这类业务的特点就是:需要延迟工作,需要进行失败重试.一种比较笨的方式是使用一个后

  • 基于rabbitmq延迟插件实现分布式延迟任务

    目录 一.延迟任务的使用场景 二.组件安装 三.RabbitMQ延迟队列插件的延迟队列实现 1.基本原理 2.核心组件开发走起 之前给大家介绍过SpringBoot集成Redisson实现延迟队列的场景分析,今天介绍下基于rabbitmq延迟插件rabbitmq_delayed_message_exchange实现延迟任务. 一.延迟任务的使用场景 1.下单成功,30分钟未支付.支付超时,自动取消订单 2.订单签收,签收后7天未进行评价.订单超时未评价,系统默认好评 3.下单成功,商家5分钟未接

  • docker安装RabbitMQ及安装延迟插件的详细过程

    目录 1.首先说一下什么是MQ 1.1为什么要用MQ/MQ有什么用 1.1.1流量消峰 1.1.2应用解耦 1.1.3异步处理 2.安装RabbitMq 2.1首先拉取镜像 2.2启动镜像 2.3启动 rabbitmq_management (RabbitMQ后台管理) 2.3.1打开RabbitMQweb界面 3.插件下载并安装 安装完成后用工具将插件文件上传到服务器上 我这个安装攻略首先得保证服务器上安装过docker了 如果没安装docker请先去安装docker 1.首先说一下什么是MQ

  • Redis延迟队列和分布式延迟队列的简答实现

    最近,又重新学习了下Redis,Redis不仅能快还能慢,简直利器,今天就为大家介绍一下Redis延迟队列和分布式延迟队列的简单实现. 在我们的工作中,很多地方使用延迟队列,比如订单到期没有付款取消订单,制订一个提醒的任务等都需要延迟队列,那么我们需要实现延迟队列.我们本文的梗概如下,同学们可以选择性阅读. 1. 实现一个简单的延迟队列. 我们知道目前JAVA可以有DelayedQueue,我们首先开一个DelayQueue的结构类图.DelayQueue实现了Delay.BlockingQue

  • Rabbitmq延迟队列实现定时任务的方法

    场景 开发中经常需要用到定时任务,对于商城来说,定时任务尤其多,比如优惠券定时过期.订单定时关闭.微信支付2小时未支付关闭订单等等,都需要用到定时任务,但是定时任务本身有一个问题,一般来说我们都是通过定时轮询查询数据库来判断是否有任务需要执行,也就是说不管怎么样,我们需要先查询数据库,而且有些任务对时间准确要求比较高的,需要每秒查询一次,对于系统小倒是无所谓,如果系统本身就大而且数据也多的情况下,这就不大现实了,所以需要其他方式的,当然实现的方式有多种多样的,比如Redis实现定时队列.基于优先

  • RabbitMQ延迟队列及消息延迟推送实现详解

    这篇文章主要介绍了RabbitMQ延迟队列及消息延迟推送实现详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 应用场景 目前常见的应用软件都有消息的延迟推送的影子,应用也极为广泛,例如: 淘宝七天自动确认收货.在我们签收商品后,物流系统会在七天后延时发送一个消息给支付系统,通知支付系统将款打给商家,这个过程持续七天,就是使用了消息中间件的延迟推送功能. 12306 购票支付确认页面.我们在选好票点击确定跳转的页面中往往都会有倒计时,代表着 3

  • 基于Redis延迟队列的实现代码

    使用场景 工作中大家往往会遇到类似的场景: 1.对于红包场景,账户 A 对账户 B 发出红包通常在 1 天后会自动归还到原账户. 2.对于实时支付场景,如果账户 A 对商户 S 付款 100 元,5秒后没有收到支付方回调将自动取消订单. 解决方案分析 方案一: 采用通过定时任务采用数据库/非关系型数据库轮询方案. 优点: 1. 实现简单,对于项目前期这样是最容易的解决方案. 缺点: 1. DB 有效使用率低,需要将一部分的数据库的QPS分配给 JOB 的无效轮询. 2. 服务资源浪费,因为轮询需

  • 手把手带你掌握SpringBoot RabbitMQ延迟队列

    目录 1. 简介 2. 安装插件 3. 实现延迟队列 3.1 引入所需依赖 3.2 application.yaml 3.3 RabbitConfig 3.4 Producer 3.5 Consumer 3.6 测试代码 3.7 启动测试 1. 简介 我们在上一篇博文中遗留了一个小问题,就是虽然TTL + DLX能实现延迟队列的功能,但是有两个问题. 首先业务场景为:比如海底捞预约,每个人预约的时间段不一致,有个可能一个小时后,有的可能三个小时等,当快到预约时间点需要给用户进行短信通知. 通过给

  • docker-compose安装RabbitMQ及插件操作步骤

    目录 准备工作 docker-compose脚本 操作步骤 执行命令 进入容器内,启动我们刚刚添加的插件 查看插件是否有安装成功 优化搭建步骤 目的 思路 步骤 准备工作 RabbitMQ默认不带延迟队列插件,可以到官网去下载指定版本的插件,并手动安装到RabbitMQ环境中,在这里我使用的RabbitMQ版本是: rabbitmq:3.8-management 延迟队列插件版本是: rabbitmq_delayed_message_exchange-3.8.9-0199d11c.ez 以上版本

  • 基于Bootstrap3表格插件和分页插件实例详解

    首先看下实现效果图,如果觉得还不错,请参考实现代码. 上面数据 下面分页 使用方法 1 导入bootstrap的css <link rel="stylesheet" href="css/v3/bootstrap.min.css"> 2 导入jquery <script src="js/jquery-1.10.1.min.js" type="text/javascript"></script>

  • 基于jQuery Circlr插件实现产品图片360度旋转

    Circlr是一款可以对产品图片进行360度全方位旋转展示的jQuery插件.Circlr通过按一定角度规律拍摄的产品图片,制作出可以使用鼠标拖动.鼠标滚轮和移动触摸来进行图片逐帧旋转的效果.比先前的Rollerblade,动画顺畅了许多,也更易于控制,该插件非常适合于商品的展示. 它的特点有: 支持水平或垂直方向旋转. 支持移动触摸事件. 支持滚动事件. 图片预加载处理. 可以反向和循环旋转图片. jQ酷实例教程:jQuery产品图片360度旋转Circlr 引入核心文件 <script sr

随机推荐