商品订单频繁项集Bolt实现

最新推荐文章于 2024-04-08 23:24:40 发布
最新推荐文章于 2024-04-08 23:24:40 发布
阅读量375 收藏
点赞数
分类专栏： storm 文章标签： Storm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengqiuming/article/details/79118944
版权
一 设计方案介绍
SplitBolt：对订单中的商品进行两两组合并发送
PairCountBolt：计算商品对出现的次数
PairTotalCountBolt：计算商品对总数
SupportComputeBolt：计算商品对的支持度
ConfidenceComputeBolt：计算商品对的置信度
FilterBolt：过滤符合条件的商品对并存入redis

二 SplitBolt实现 
package com.hust.grid.leesf.ordertest.bolt;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.hust.grid.leesf.ordertest.common.FieldNames;
import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
/**
 * 对订单中的商品进行两两组合并发送
 *
 * @author leesf
 *
 */
public class SplitBolt extends BaseRichBolt {
     private static final long serialVersionUID = 1L;
     private OutputCollector collector;
     private Map<String, List<String>> orderItems; // 存储订单及其商品
     public void prepare(@SuppressWarnings("rawtypes") Map conf, TopologyContext context, OutputCollector collector) {
           this.collector = collector;
           orderItems = new HashMap<String, List<String>>();
     }
     public void execute(Tuple tuple) {
           // 获取订单号和商品名称
           String id = tuple.getStringByField(FieldNames.ID);
           String newItem = tuple.getStringByField(FieldNames.NAME);
           if (!orderItems.containsKey(id)) { // 不包含该订单
                // 新生商品链表
                ArrayList<String> items = new ArrayList<String>();
                // 添加商品
                items.add(newItem);
                orderItems.put(id, items);
                return;
           }
           // 包含订单，取出订单中包含的商品
           List<String> items = orderItems.get(id);
           for (String existItem : items) { // 遍历商品
                // 将元组中提取的商品与订单中已存在的商品组合后发射
                collector.emit(createPair(newItem, existItem));
           }
           // 添加新的商品
           items.add(newItem);
     }
     private Values createPair(String item1, String item2) { // 按照指定顺序生成商品对
           if (item1.compareTo(item2) > 0) {
                return new Values(item1, item2);
           }
           return new Values(item2, item1);
     }
     public void declareOutputFields(OutputFieldsDeclarer declarer) {
           // 声明元组字段
           declarer.declare(new Fields(FieldNames.ITEM1, FieldNames.ITEM2));
     }
}

三 PairCountBolt实现 
package com.hust.grid.leesf.ordertest.bolt;

import java.util.HashMap;
import java.util.Map;

import com.hust.grid.leesf.ordertest.common.FieldNames;
import com.hust.grid.leesf.ordertest.common.ItemPair;

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

/**
* 计算商品对出现的次数
*
* @author leesf
*
*/
public class PairCountBolt extends BaseRichBolt {
    private static final long serialVersionUID = 1L;

    private OutputCollector collector;
    private Map<ItemPair, Integer> pairCounts; // 存储商品对及其出现的次数

    public void prepare(@SuppressWarnings("rawtypes") Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        this.pairCounts = new HashMap<ItemPair, Integer>();
    }

    public void execute(Tuple tuple) {
        String item1 = tuple.getStringByField(FieldNames.ITEM1);
        String item2 = tuple.getStringByField(FieldNames.ITEM2);

        ItemPair itemPair = new ItemPair(item1, item2);
        int pairCount = 0;

        if (pairCounts.containsKey(itemPair)) { // 包含商品对
            // 取出商品对出现的次数
            pairCount = pairCounts.get(itemPair);
        }
        // 更新出现次数
        pairCount++;

        pairCounts.put(itemPair, pairCount);

        collector.emit(new Values(item1, item2, pairCount));
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        // 声明元组字段
        declarer.declare(new Fields(FieldNames.ITEM1, FieldNames.ITEM2, FieldNames.PAIR_COUNT));
    }
}

四 PairTotalCountBolt实现 
package com.hust.grid.leesf.ordertest.bolt;

import java.util.Map;

import com.hust.grid.leesf.ordertest.common.FieldNames;

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

/**
* 计算商品对总数
*
* @author leesf
*
*/
public class PairTotalCountBolt extends BaseRichBolt {
    private static final long serialVersionUID = 1L;

    private OutputCollector collector;
    private int totalCount; // 商品对总数

    public void prepare(@SuppressWarnings("rawtypes") Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        totalCount = 0;
    }

    public void execute(Tuple tuple) {
        totalCount++; // 每收到一个元组，便增加商品对总数
        collector.emit(new Values(totalCount)); // 发射商品对总数
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        // 声明元组字段
        declarer.declare(new Fields(FieldNames.TOTAL_COUNT));
    }
}
五 SupportComputeBolt实现 
package com.hust.grid.leesf.ordertest.bolt;

import java.util.HashMap;
import java.util.Map;

import com.hust.grid.leesf.ordertest.common.FieldNames;
import com.hust.grid.leesf.ordertest.common.ItemPair;

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

/**
* 计算商品对的支持度
*
* @author leesf
*
*/
public class SupportComputeBolt extends BaseRichBolt {
    private static final long serialVersionUID = 1L;

    private OutputCollector collector;
    private Map<ItemPair, Integer> pairCounts; // 存储商品对及其出现的次数
    private int pairTotalCount; // 商品对总数

    public void prepare(@SuppressWarnings("rawtypes") Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        pairCounts = new HashMap<ItemPair, Integer>();
        pairTotalCount = 0;
    }

    /**
     * 由于SupportComputeBolt订阅了多个流，其需要根据不同的字段做出不同的行为
     */
    public void execute(Tuple tuple) {
        if (tuple.getFields().get(0).equals(FieldNames.TOTAL_COUNT)) { // 对应PairTotalCountBolt
            // 取出商品对总数量
            pairTotalCount = tuple.getIntegerByField(FieldNames.TOTAL_COUNT);
        } else if (tuple.getFields().size() == 3) { // 对应PairCountBolt
            // 取出商品及其商品对出现的次数
            String item1 = tuple.getStringByField(FieldNames.ITEM1);
            String item2 = tuple.getStringByField(FieldNames.ITEM2);
            int pairCount = tuple.getIntegerByField(FieldNames.PAIR_COUNT);
            // 存储商品对及其次数
            pairCounts.put(new ItemPair(item1, item2), pairCount);
        } else if (tuple.getFields().get(0).equals(FieldNames.COMMAND)) { // 对应CommandSpout
            for (ItemPair itemPair : pairCounts.keySet()) { // 遍历商品对
                // 计算商品支持度，使用商品对出现的次数除以商品对总数量
                double itemSupport = (double) (pairCounts.get(itemPair).intValue()) / pairTotalCount;

                collector.emit(new Values(itemPair.getItem1(), itemPair.getItem2(), itemSupport));
            }
        }
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        // 定义元组字段
        declarer.declare(new Fields(FieldNames.ITEM1, FieldNames.ITEM2, FieldNames.SUPPORT));
    }

}

六 ConfidenceComputeBolt实现 
package com.hust.grid.leesf.ordertest.bolt;

import java.util.HashMap;
import java.util.Map;

import com.hust.grid.leesf.ordertest.common.ConfKeys;
import com.hust.grid.leesf.ordertest.common.FieldNames;
import com.hust.grid.leesf.ordertest.common.ItemPair;

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
import redis.clients.jedis.Jedis;

/**
* 计算商品对的置信度
*
* @author leesf
*/
public class ConfidenceComputeBolt extends BaseRichBolt {
    private static final long serialVersionUID = 1L;

    private OutputCollector collector;
    private Map<ItemPair, Integer> pairCounts; // 存储商品对及其出现的次数

    private String host;
    private int port;
    private Jedis jedis;

    public void prepare(@SuppressWarnings("rawtypes") Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        this.host = conf.get(ConfKeys.REDIS_HOST).toString();
        this.port = Integer.parseInt(conf.get(ConfKeys.REDIS_PORT).toString());
        pairCounts = new HashMap<ItemPair, Integer>();
        connectToRedis();
    }

    private void connectToRedis() {
        jedis = new Jedis(host, port);
        jedis.connect();
    }

    /**
     * 由于ConfidenceComputeBolt订阅了多个流，其需要根据元组不同的字段做出不同的行为
     */
    public void execute(Tuple tuple) {
        if (tuple.getFields().size() == 3) { // 对应PairCountBolt
            // 取出商品对及其出现次数
            String item1 = tuple.getStringByField(FieldNames.ITEM1);
            String item2 = tuple.getStringByField(FieldNames.ITEM2);
            int pairCount = tuple.getIntegerByField(FieldNames.PAIR_COUNT);

            pairCounts.put(new ItemPair(item1, item2), pairCount);
        } else if (tuple.getFields().get(0).equals(FieldNames.COMMAND)) { // 对应CommandSpout，需要进行统计
            for (ItemPair itemPair : pairCounts.keySet()) { // 遍历商品对
                // 从redis中取出商品对中商品出现的次数
                double item1Count = Integer.parseInt(jedis.hget("itemCounts", itemPair.getItem1()));
                double item2Count = Integer.parseInt(jedis.hget("itemCounts", itemPair.getItem2()));
                double itemConfidence = pairCounts.get(itemPair).intValue();

                // 计算商品对置信度
                if (item1Count < item2Count) {
                    itemConfidence /= item1Count;
                } else {
                    itemConfidence /= item2Count;
                }

                collector.emit(new Values(itemPair.getItem1(), itemPair.getItem2(), itemConfidence));
            }
        }
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        // 声明元组字段
        declarer.declare(new Fields(FieldNames.ITEM1, FieldNames.ITEM2, FieldNames.CONFIDENCE));
    }
}

七 FilterBolt实现 
package com.hust.grid.leesf.ordertest.bolt;

import java.util.Map;

import org.json.simple.JSONObject;

import com.hust.grid.leesf.ordertest.common.ConfKeys;
import com.hust.grid.leesf.ordertest.common.FieldNames;
import com.hust.grid.leesf.ordertest.common.ItemPair;

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
import redis.clients.jedis.Jedis;

/**
* 过滤符合条件的商品对并存入redis
*
* @author leesf
*
*/
public class FilterBolt extends BaseRichBolt {
    private static final long serialVersionUID = 1L;

    // 商品对的支持度和置信度
    private static final double SUPPORT_THRESHOLD = 0.01;
    private static final double CONFIDENCE_THRESHOLD = 0.01;

    private OutputCollector collector;

    private Jedis jedis;
    private String host;
    private int port;

    public void prepare(@SuppressWarnings("rawtypes") Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        this.host = conf.get(ConfKeys.REDIS_HOST).toString();
        this.port = Integer.parseInt(conf.get(ConfKeys.REDIS_PORT).toString());
        connectToRedis();
    }

    private void connectToRedis() {
        jedis = new Jedis(host, port);
        jedis.connect();
    }

    @SuppressWarnings("unchecked")
    public void execute(Tuple tuple) {
        // 取出商品并构造商品对
        String item1 = tuple.getStringByField(FieldNames.ITEM1);
        String item2 = tuple.getStringByField(FieldNames.ITEM2);
        ItemPair itemPair = new ItemPair(item1, item2);
        String pairString = itemPair.toString();

        double support = 0;
        double confidence = 0;

        if (tuple.getFields().get(2).equals(FieldNames.SUPPORT)) { // 对应SupportComputeBolt
            // 获取支持度并存入redis
            support = tuple.getDoubleByField(FieldNames.SUPPORT);
            jedis.hset("supports", pairString, String.valueOf(support));
        } else if (tuple.getFields().get(2).equals(FieldNames.CONFIDENCE)) { // 对应ConfidenceComputeBolt
            // 获取置信度并存入redis
            confidence = tuple.getDoubleByField(FieldNames.CONFIDENCE);
            jedis.hset("confidences", pairString, String.valueOf(confidence));
        }

        if (!jedis.hexists("supports", pairString) || !jedis.hexists("confidences", pairString)) { // 商品对的支持度和置信度还未计算完成，返回
            return;
        }
        // 商品对的支持度和置信度已经计算完成
        support = Double.parseDouble(jedis.hget("supports", pairString));
        confidence = Double.parseDouble(jedis.hget("confidences", pairString));

        if (support >= SUPPORT_THRESHOLD && confidence >= CONFIDENCE_THRESHOLD) { // 支持度和置信度超过阈值
            // 将该商品对信息存入redis中
            JSONObject pairValue = new JSONObject();
            pairValue.put(FieldNames.SUPPORT, support);
            pairValue.put(FieldNames.CONFIDENCE, confidence);

            jedis.hset("recommendedPairs", pairString, pairValue.toJSONString());

            collector.emit(new Values(item1, item2, support, confidence));
        } else { // 不高于阈值，则从redis中删除
            jedis.hdel("recommendedPairs", pairString);
        }
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        // 声明元组字段
        declarer.declare(new Fields(FieldNames.ITEM1, FieldNames.ITEM2, FieldNames.SUPPORT, FieldNames.CONFIDENCE));
    }
}

八 参考
chengqiuming
关注
专栏目录
数据挖掘中的模式发现（一）频繁项集、频繁闭项集、最大频繁项集
Mr.Phoebe的专栏
01-26 4万+
Frequent Itemset(频繁项集)称I={i1,i2,...,im}I=\{i_1, i_2, ..., i_m\}为项(Item)的集合，D={T1,T2,...,Tn}D=\{T_1, T_2, ...,T_n\}，i∈[1,n]i∈[1,n]为事务数据集(Transaction Data Itemsets)，事务TiT_i由II中若干项组成。设SS为由项组成的一个集合，S={i|i∈
关联规则—频繁项集Apriori算法
热门推荐
liyonghui123的专栏
06-16 1万+
      频繁模式和对应的关联或相关规则在一定程度上刻画了属性条件与类标号之间的有趣联系，因此将关联规则挖掘用于分类也会产生比较好的效果。关联规则就是在给定训练项集上频繁出现的项集与项集之间的一种紧密的联系。其中“频繁”是由人为设定的一个阈值即支持度 （support）来衡量，“紧密”也是由人为设定的一个关联阈值即置信度（confidence）来衡量的。这两种度量标准是频繁项集挖掘中两个至关...
商品订单频繁项集Spout实现
实践求真知
01-21 307
一 需求 通过OrderSpout读取Redis中的订单数据，以供拓扑结构下游的Bolt使用。 通过CommandSpout实现统计支持度和置信度。 二 OrderSpout实现 package com.hust.grid.leesf.ordertest.spout; import java.util.Map; import org.json.simple.JSONArray; i
商品订单频繁项集Toplogy实现
实践求真知
01-22 335
一 代码实现 package com.hust.grid.leesf.ordertest.bolt; import java.util.HashMap; import java.util.Map; import com.hust.grid.leesf.ordertest.common.ConfKeys; import com.hust.grid.leesf.ordertest.common.
商品订单频繁项集详细设计
实践求真知
01-14 545
一 拓扑结构图 二 实现步骤 1.产生订单数据 通过模拟程序产生订单数据，并存储Redis中，即使用OrderGenerator来生成订单数据并存入Redis中，每个订单有四种不同商品及其数量组成。 2. 接入订单数据 通过OrderSpout读取Redis中的订单数据，以供拓扑结构下游的Bolt使用。 3. 对订单中商品进行分组 通过SplitBolt对订单中的商品进行
商品频繁二项集挖掘方法
实践求真知
01-14 2366
一 频繁二项集 现实中有许多关联规则挖掘算法，比如最著名的Apriori算法，以及FP-树频集算法，本例介绍关于商品的频繁二项集算法。 二 算法设计思路 1 将每一笔订单的商品按照两两分组 2 对每个分组的频数进行统计 3 根据频数计算支持度和置信度 4 设置支持度与置信度阈值，过滤不达标的数据 三 Apache Storm实现思路 1 使用Redis作为存储订单数
【Storm】Storm实战之频繁二项集挖掘（附源码）
weixin_30855099的博客
07-14 71
一、前言 　　针对大叔据实时处理的入门，除了使用WordCount示例之外，还需要相对更深入点的示例来理解Storm，因此，本篇博文利用Storm实现了频繁项集挖掘的案例，以方便更好的入门Storm。 二、基础知识 　　2.1 频繁二项集挖掘 　　如顾客去超市购物时，牙膏和牙刷基本上都是摆放在一起，因为购买牙膏时，很有可能会购买牙刷。另外，“啤酒与尿布”的案例则是对订单进行分析挖掘后发现的...
电商技术揭秘十四：大数据平台的选择与构建
最新发布
沛哥儿的专栏
04-08 1319
大数据技术的核心在于处理和分析大规模数据集，以便从中提取有价值的信息。在电商领域，这涉及到用户行为分析、市场趋势预测、个性化推荐等多个方面。通过大数据技术，电商平台能够更深入地理解用户需求，优化服务，提升用户体验。Apache Hadoop是一个由Apache软件基金会开发的开源框架，它使得分布式处理大规模数据集变得可行。Hadoop基于Google的MapReduce编程模型，通过将大型数据集分割成小的数据块（chunks）并在多台计算机上并行处理这些数据块，从而实现快速处理。特点高可靠性。
Storm ：商品订单频繁项集挖掘,组合查找源码
01-06
总的来说，`Storm` 在商品订单频繁项集挖掘中的应用，结合数据挖掘算法，能够实现实时的关联规则发现，为电商推荐系统提供强大的支持，提升用户体验，增加销售潜力。这体现了实时计算框架在大数据时代的重要性，以及...
BigData导论
xidiancyp的博客
05-20 719
大数据导论
大数据技术之高频面试题
XIAOMO__的博客
11-12 9118
第一章 项目涉及技术 1.1Linux&Shell 1.1.1 Linux常用高级命令 序号 命令 命令解释 1 top 查看内存 2 df -h 查看磁盘存储情况 3 iotop 查看磁盘IO读写(yum install iotop安装） .
storm系统监控
实践求真知
01-14 2022
一 监控系统的重要性 二 系统监控的几大指标 三 系统监控的初步解决方案 四 参考 http://www.jikexueyuan.com/course/2150.html
Storm 的扩展：与 YARN 的结合
实践求真知
01-05 2019
一 关于YQRN 二 Storm与Yarn结合优势 三 当前存在问题
Storm主要特点
实践求真知
01-05 1771
主要特点
Storm 的现状与发展趋势
实践求真知
01-05 1587
一 Storm的应用场景 二 实时处理相关系统架构 三 Storm与Hadoop的对比 四 Storm发展趋势
storm发展历史
实践求真知
01-05 1465
一 Storm发展历史 二 Storm的历史版本
商品订单频繁项集生成订单数据
实践求真知
01-21 1264
一 需求 生成30个订单，每个订单有4件商品，将订单数据存放到Redis数据库。 二 代码OrderGenerator package com.hust.grid.leesf.ordertest.common; import java.util.HashSet; import java.util.Random; import java.util.Set; import java.u
元数据管理器
实践求真知
01-13 1076
一 什么是元数据 二 为何要引入元数据 三 实时处理平台任务调度 四 参考 http://www.jikexueyuan.com/course/2150.html
Storm 实战基础 ——WordCount 实例需求与设计
实践求真知
01-13 1047
一 效果展示 1、运行命令 命令解析：storm jar 程序名 程序运行类 topology命名 2、UI查看 3、数据生成查看方式 4、数据生成结果 二 Storm应用实例需求分析 三 与hadoop的wordcount实例对比 四 Storm的编程模型 五 方案及拓扑设计 六 参考 http://w
使用JavaScript实现Bolt让守时更简单
在本资源中，我们将探讨如何使用JavaScript来实现一个名为'bolt'的项目，该项目的目标是帮助人们更加守时。 JavaScript在'bolt'项目中的应用主要体现在以下几个方面：首先，JavaScript可以用来创建一个实时的计时器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值