Flink（63）：Flink中通用RedisUtil工具类

最新推荐文章于 2024-06-20 20:04:14 发布
最新推荐文章于 2024-06-20 20:04:14 发布
阅读量2k 收藏 7
点赞数 1
分类专栏： # Flink 文章标签： flink 大数据 redis big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang_shibiao/article/details/128509822
版权

目录

0. 相关文章链接

1. 开发目的

2. 导入依赖

3. 代码

3.1. 使用SpringBoot中的RedisTemplate实现

3.2. 使用Jedis实现

3.3. 通用工具类

4. 如何使用

0. 相关文章链接

Flink文章汇总

1. 开发目的

        在使用SpringBoot后端开发中，我们如果需要对Redis进行增删查改，可以很方便的使用RedisTemplate或者StringRedisTemplate等对象进行操作。但是在大数据中，如果想要对Redis进行操作，就没有那么方便，特别当flink新一代流式计算框架兴起后，没有直接读取和写入Redis的连接源，不管是开始的时候从Redis中获取数据，还是在中间需要读取维度数据，或者最后将数据写入到Redis，都不方便。此时一个较为方便的工具类就能很方便的使用，能达到节省开发时间、减小开发难度等目的。

2. 导入依赖


    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <scala.binary.version>2.11</scala.binary.version>
        <scala.version>2.11.8</scala.version>
        <flink.binary.version>1.10</flink.binary.version>
        <flink.version>1.10.0</flink.version>
        <log4j.version>1.2.17</log4j.version>
        <slf4j.version>1.7.21</slf4j.version>
        <mysql.version>8.0.21</mysql.version>
        <fastjson.version>2.0.20</fastjson.version>
        <avro.version>1.11.0</avro.version>
        <huaweicloud.dws.jdbc.version>8.1.0</huaweicloud.dws.jdbc.version>
        <commons.beanutils.version>1.9.4</commons.beanutils.version>
        <guava.version>29.0-jre</guava.version>
        <okhttp.version>3.6.0</okhttp.version>
        <springboot.version>2.3.3.RELEASE</springboot.version>
        <hikari.cp.version>2.6.1</hikari.cp.version>
        <avro.version>1.10.0</avro.version>
        <jedis.version>4.2.0</jedis.version>
        <commons.lang.version>3.10</commons.lang.version>
        <huaweicloud.obs.version>3.21.4</huaweicloud.obs.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>


    <dependencies>

        <!-- flink相关jar包 -->
        <!--flink流的核心包-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--flink中的Table相关包-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- flink连接kafka-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--flink的rocksdb包-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-statebackend-rocksdb_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--MySQL驱动包 mysql8版本-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- jdbc连接池包（使用JDBCTemplate） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
            <version>${springboot.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>${hikari.cp.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--redis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${jedis.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- 华为云GaussDB的连接JDBC的Jar包 -->
        <dependency>
            <groupId>com.huaweicloud.dws</groupId>
            <artifactId>huaweicloud-dws-jdbc</artifactId>
            <version>${huaweicloud.dws.jdbc.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- 日志打印的jar包 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- json解析包，fastjson包 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- avro压缩包 -->
        <dependency>
            <groupId>org.apache.avro</groupId>
            <artifactId>avro</artifactId>
            <version>${avro.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--commons-beanutils 是 Apache 开源组织提供的用于操作 JAVA BEAN 的工具包。使用 commons-beanutils，我们可以很方便的对 bean 对象的属性进行操作-->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>${commons.beanutils.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--Guava 工程包含了若干被 Google 的 Java 项目广泛依赖的核心库,方便开发-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- 共有的lang包 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons.lang.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- http包 -->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>${okhttp.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- 华为云连接OBS包 -->
        <dependency>
            <groupId>com.huaweicloud</groupId>
            <artifactId>esdk-obs-java</artifactId>
            <version>${huaweicloud.obs.version}</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <artifactSet>
                                <excludes>
                                    <exclude>com.google.code.findbugs:jsr305</exclude>
                                    <exclude>org.slf4j:*</exclude>
                                    <exclude>log4j:*</exclude>
                                    <exclude>org.apache.hadoop:*</exclude>
                                </excludes>
                            </artifactSet>
                            <filters>
                                <filter>
                                    <!-- Do not copy the signatures in the META-INF folder.
                                    Otherwise, this might cause SecurityExceptions when using the JAR. -->
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                        <exclude>*.properties</exclude>
                                        <exclude>*.xml</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers combine.children="append">
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer">
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

3. 代码

注意：下述代码中使用了自定义的ModelUtil工具类，该工具类的具体介绍可以参考博主的另一篇博文：Flink（60）：Flink中通用ModelUtil工具类

3.1. 使用SpringBoot中的RedisTemplate实现

注意：下述方法为静态工具类，在使用时，直接使用RedisMlUtil调用方法即可；而且因为是静态工具类，所以这个类的库固定了，只能访问这个一个库的数据，如果需要其他的Redis集群可以再创建类似工具类（一般一个公司的Redis集群不会很多，所以一般用来读取数据的工具类，使用静态的即可）。并且其中的连接池的大小、超时时间等参数已进行固定（该参数可以根据公司集群来调节，博主使用的集群用如下配置即可）。另外还有，该类是静态，所以在每台机器上只会创建一个对象，这样连接池等大小就需要配置的大一点。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;

/**
 * @date: 2022/12/29
 * @author: yangshibiao
 * @desc: ml-redis集群工具类
 */
public class RedisMlUtil {

    static Logger logger = LoggerFactory.getLogger(RedisMlUtil.class);

    /**
     * StringRedisTemplate对象
     */
    private static StringRedisTemplate stringRedisTemplate;

    /**
     * 获取StringRedisTemplate对象
     *
     * @return StringRedisTemplate对象
     */
    public static StringRedisTemplate getStringRedisTemplate() {

        if (stringRedisTemplate == null) {
            synchronized (RedisMlUtil.class) {
                if (stringRedisTemplate == null) {

                    // 创建 Jedis连接池 配置对象
                    JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
                    jedisPoolConfig.setMaxTotal(50);
                    jedisPoolConfig.setMaxIdle(50);
                    jedisPoolConfig.setMinIdle(5);

                    // 通过 Jedis连接池配置 创建 jedis客户端 配置对象
                    JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfigurationBuilder = JedisClientConfiguration.builder();
                    jedisClientConfigurationBuilder.connectTimeout(Duration.ofMillis(3000));
                    jedisClientConfigurationBuilder.usePooling().poolConfig(jedisPoolConfig);
                    JedisClientConfiguration jedisClientConfiguration = jedisClientConfigurationBuilder.build();

                    // 创建 redis 配置对象
                    RedisStandaloneConfiguration redisConfiguration = new RedisStandaloneConfiguration();
                    redisConfiguration.setHostName(ModelUtil.getConfigValue("redis.ml.hostname"));
                    redisConfiguration.setPort(Integer.parseInt(ModelUtil.getConfigValue("redis.ml.port")));
                    redisConfiguration.setPassword(RedisPassword.of(ModelUtil.getConfigValue("redis.ml.password")));
                    redisConfiguration.setDatabase(Integer.parseInt(ModelUtil.getConfigValue("redis.ml.database")));

                    // 通过 jedis客户端配置对象 和 redis配置对象 创建Jedis连接工厂
                    JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisConfiguration, jedisClientConfiguration);

                    // 通过 Jedis连接工厂 创建 redisTemplate
                    stringRedisTemplate = new StringRedisTemplate(jedisConnectionFactory);

                    logger.info(
                            "##### 创建ml-redis集群客户端StringRedisTemplate对象成功，其中最大连接数为：{}，空闲连接数为：{}，连接地址为：{}",
                            50,
                            5,
                            ModelUtil.getConfigValue("redis.ml.hostname")
                    );

                }
            }
        }

        return stringRedisTemplate;

    }

    /**
     * 通过传入的key获取对应的value值
     *
     * @param key 键
     * @return 值
     */
    public static String getValue(String key) {
        return RedisMlUtil.getStringRedisTemplate().opsForValue().get(key);
    }

}

3.2. 使用Jedis实现

注意：下述方法为静态工具类，在使用时，直接使用RedisMlUtil调用方法即可；而且因为是静态工具类，所以这个类的库固定了，只能访问这个一个库的数据，如果需要其他的Redis集群可以再创建类似工具类（一般一个公司的Redis集群不会很多，所以一般用来读取数据的工具类，使用静态的即可）。并且其中的连接池的大小、超时时间等参数已进行固定（该参数可以根据公司集群来调节，博主使用的集群用如下配置即可）。另外还有，该类是静态，所以在每台机器上只会创建一个对象，这样连接池等大小就需要配置的大一点。


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @date: 2022/12/29
 * @author: yangshibiao
 * @desc: ml-redis集群工具类
 */
public class RedisMlUtil {

    static Logger logger = LoggerFactory.getLogger(RedisMlUtil.class);

    /**
     * JedisPool对象
     */
    private static JedisPool jedisPool;

    /**
     * 获取JedisPool对象
     *
     * @return JedisPool对象
     */
    public static JedisPool getJedisPool() {

        if (jedisPool == null) {
            synchronized (RedisMlUtil.class) {
                if (jedisPool == null) {
                    JedisPoolConfig poolConfig = new JedisPoolConfig();
                    poolConfig.setMaxTotal(50);
                    poolConfig.setMaxIdle(50);
                    poolConfig.setMinIdle(5);
                    jedisPool = new JedisPool(
                            poolConfig,
                            ModelUtil.getConfigValue("redis.ml.hostname"),
                            Integer.parseInt(ModelUtil.getConfigValue("redis.ml.port")),
                            3000,
                            ModelUtil.getConfigValue("redis.ml.password")
                    );
                    logger.info(
                            "根据传入的参数创建redis连接池jedisPool对象成功，使用的host为：{}，使用的port为：{}，最大连接数为{}，最大空闲连接数为{}，最小空闲连接数为：{}，连接超时时间为(毫秒)：{}",
                            ModelUtil.getConfigValue("redis.ml.hostname"),
                            Integer.parseInt(ModelUtil.getConfigValue("redis.ml.port")),
                            50,
                            50,
                            5,
                            3000
                    );
                }
            }
        }

        return jedisPool;

    }

    /**
     * 获取对应的 Jedis
     * 注意：该jedis对象是从连接池中返回，使用完之后需要关闭
     *
     * @param index redis对应的索引
     * @return Jedis
     */
    public static Jedis getJedis(int index) {
        Jedis jedis = getJedisPool().getResource();
        jedis.select(index);
        return jedis;
    }

    /**
     * 通过传入的key获取对应的value值
     *
     * @param key 键
     * @return 值
     */
    public static String getValue(int index, String key) {
        Jedis jedis = getJedis(index);
        String value = jedis.get(key);
        jedis.close();
        return value;
    }

}

3.3. 通用工具类

注意：该工具类没有使用静态，所以在每次使用的时候，需要在open方法中创建该工具类对象，然后在process方法中使用该工具类中的方法即可。此工具类即可以用于维度等数据读取，又能用于将结果数据写入，并且每次创建工具类的时候，可以指定不同的Redis集群和不同的参数。同样，因为每次使用时都创建该类的对象，这样Flink程序中每一个并发，所以在使用时需要注意连接池等参数不要配置的太大。


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @date: 2022/12/6
 * @author: yangshibiao
 * @desc: RedisUtil
 */
public class RedisUtil {

    static Logger logger = LoggerFactory.getLogger(RedisUtil.class);

    /**
     * jedis连接池
     */
    private JedisPool jedisPool;

    /**
     * 通过传入的参数创建RedisUtil对象
     *
     * @param host     redis的host
     * @param port     redis的端口
     * @param password redis的password
     */
    public RedisUtil(String host, int port, String password) {
        initJedisPool(host, port, password, 2, 2, 1, 3000);
    }

    /**
     * 通过传入的参数创建RedisUtil对象
     *
     * @param host     redis的host
     * @param port     redis的端口
     * @param password redis的password
     * @param maxTotal 连接池中最大连接数
     * @param maxIdle  连接池中最大空闲连接数
     * @param minIdle  连接池中最小空闲连接数
     * @param timeout  连接Redis超时时间
     */
    public RedisUtil(String host, int port, String password, int maxTotal, int maxIdle, int minIdle, int timeout) {
        initJedisPool(host, port, password, maxTotal, maxIdle, minIdle, timeout);
    }

    /**
     * 初始化Jedis对象
     *
     * @param host     redis的host
     * @param port     redis的端口
     * @param password redis的password
     * @param maxTotal 连接池中最大连接数
     * @param maxIdle  连接池中最大空闲连接数
     * @param minIdle  连接池中最小空闲连接数
     * @param timeout  连接Redis超时时间
     */
    public void initJedisPool(String host, int port, String password, int maxTotal, int maxIdle, int minIdle, int timeout) {

        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxTotal);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        jedisPool = new JedisPool(
                poolConfig,
                host,
                port,
                timeout,
                password
        );

        logger.info(
                "根据传入的参数创建redis连接池jedisPool对象成功，使用的host为：{}，使用的port为：{}，最大连接数为{}，最大空闲连接数为{}，最小空闲连接数为：{}，连接超时时间为(毫秒)：{}",
                host,
                port,
                maxTotal,
                maxIdle,
                minIdle,
                timeout
        );

    }

    /**
     * 获取对应的 Jedis
     * 注意：该jedis对象是从连接池中返回，使用完之后需要关闭
     *
     * @param index redis对应的索引
     * @return Jedis
     */
    public Jedis getJedis(int index) {
        Jedis jedis = jedisPool.getResource();
        jedis.select(index);
        return jedis;
    }

    /**
     * 根据传入的数据库索引和key获取对应的值
     * 注意：如果该key不存在，就返回 'nil'，如果存储在key的值不是字符串，则返回错误
     *
     * @param index redis的索引
     * @param key   redis的key
     * @return value
     */
    public String getValue(int index, String key) {
        Jedis jedis = getJedis(index);
        String value = jedis.get(key);
        jedis.close();
        return value;
    }

}

4. 如何使用

在Flink作业中如何使用上述工具类，可以参考博主的另一篇MySQL工具类文章：Flink（62）：Flink中通用MySQLUtil工具类，使用基本相似，这里就不再过多描述了。

注：其他相关文章链接由此进 -> Flink文章汇总

电光闪烁
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Flink与Redis集成：自定义连接器实现维表创建与数据汇入
击水三千里的专栏
01-31 632
本文详细介绍了如何在Apache Flink中通过自定义连接器与Redis进行数据交互，包括创建Redis维表和实现数据汇入。文章展示了如何利用现有的Redis连接器和Flink的动态表特性，通过自定义的Source和Sink，实现流式数据与Redis维表的实时Join操作，以及如何将数据批量写入Redis。此外，还探讨了如何通过缓存优化和复用现有格式来提高性能。
Flink笔记(二十四)：Flink 数据 保存 Redis(自定义Redis Sink)
01-07
本文主要来介绍 Flink 读取 Kafka数据，并实时下沉(Sink)数据到 Redis 的过程。        通过如下链接：Flink官方文档，我们知道数据保存到 Redis 的容错机制是 at least once。所以我们通过幂等操作，使用新数据覆盖旧数据的方式，以此来实现 exactly-once 。 1.代码部分 1.1 config.properties配置文件 bootstrap.server=192.168.204.210:9092,192.168.204.211:9092,192.168.204.212:9092 group.id=testGroup auto.offse
flink连接redis工具类-简单好用
weixin_45399602的博客
05-07 3068
简单易容的flink redis 工具
Flink Sql Redis Connector
最新发布
bigdatakenan的博客
06-20 1402
以下为sql读取结果，直接将redis数据解析成我们需要的表格形式。
Flink-Connectors(连接器)（2）Redis
胖虎儿的博客
04-12 6855
flink 提供了专门操作redis 的RedisSink，使用起来更方便，而且不用我们考虑性能的问题，接下来将主要介绍RedisSink 如何使用
《高级》Flink异步io链接Redis--Java和Scala版
huzechen的博客
08-21 3086
最近发现好多小伙伴不知道如何异步链接redis 我准备了两个版本 java版本和scala版本 直接上代码，大部分同学看了应该会懂 刚开始学习flink的同学中间细节的东西，不明白的可以微信联系我，可以进入我的flink微信交流群。 喜欢flink的朋友，支持一下原创，可以关注我的公众号： 先看java版本 import com.alibaba.fastjson....
Flink 系例 之 Connectors 连接 Redis
不会飞的小龙人的博客
01-31 1653
通过使用 Flink DataStream Connectors 数据流连接器连接到 Redis 缓存数据库，并提供数据流输入与输出操作；
Flink维表关联之Redis(java实现)
znmdwzy的博客
08-06 2629
需求背景： 需要流数据与Redis数据进行关联查询。通常情况下Flink可以通过RichMapFunction来创建外部数据系统的client连接，来进行数据的写入和数据的读取。但这种同步查询和操作数据库的方式会因网络等问题影响数据处理的效率，如果想提升效率就要考虑增加算子的并行度，这会增多额外的资源开销。写这个也是网上java实现的资料太少了！ 解决思路： Flink在1.2版本中引入了Asynchronous I/O，能够支持异步的方式连接外部的存储系统，从而提升Flink系统与外部数据库交互的性能与吞
Flink接入Redis
qq_27642017的博客
06-08 354
创建Redis连接池 RedisUtils 写入数据到Redis，可根据自己的需求使用Redis存储类型，我这里写的是list集合
Flink集成Redis组件，使用异步IO能完全解决性能瓶颈问题？
JK_GOME的博客
05-02 2672
基于上述的问题，我们先来对异步IO有个大致的认识，了解的同学可以选择跳过。 流计算系统中经常需要与外部系统（Redis、MySQL等）进行交互，我们通常的做法如向数据库发送用户a的查询请求，然后等待结果返回，在这之前，我们的程序无法发送用户b的查询请求。这是一种同步访问方式，如下图所示。 图中棕色的长条表示等待时间，可以发现网络等待时间极大地阻碍了吞吐和延迟。为了解决同步访问的问题，异步模...
轻松通关Flink第34讲：Flink 和 Redis 整合以及 Redis Sink 实现
sucaiwa的博客
03-29 2766
这节课我们学习了 Flink 计算 PV、UV后的结果分别写入 Redis、MySQL 和 HBase。我们在实际业务中可以选择使用不同的目标库，你可以在本文中找到对应的实现根据实际情况进行修改来使用。
flink-connector-redis_2.11-1.1.5.jar
08-09
flink连接redis设置过期时间和密码
重写代码实现Flink连接Redis集群（Java版，解决Flink无法连接私有IP Redis集群问题）
天然玩家的博客
07-16 1841
（1）第三方Redis连接工具[bahir](https://bahir.apache.org/docs/flink/current/flink-streaming-redis)使用InetSocketAddress配置Redis集群节点IP和PORT，无法连接私有IP的Redis集群； （2）重写连接Redis集群代码，直接通过HostAndPort方式设置节点IP和PORT，保证私有的IP同样可以连接Redis集群； （3）Flink原生不支持Redis连接，执行Redis相关类型任务需要将Redis相
flink维表查询redis之flink-connector-redis
zilong00007的专栏
03-10 6878
相对bahir增加的内容有：Table API, 维表查询。参考了腾讯云与阿里云两家主流云产商的流计算产品，取两家之长，并增加了更丰富的功能。
Flink的Redis-Sink
shufangreal的博客
03-02 642
Flink的Redis-Sink 具体实现步骤如下： 可以参考Flink的官网RedisSink的具体实现： https://bahir.apache.org/docs/flink/current/flink-streaming-redis/ 1.引入官方的flink-redis-connector的maven依赖 <!-- https://mvnrepository.com...
flink入门3-Flink连接Kafka、Redis，实现Kafka Source/Redis Sink
summon的博客
06-07 2413
本篇文章将会一步步实现如何使用Flink对接Kafka和Redis，并将Kafka中的数据存储到Redis中，这种场景也是真实项目会遇到的。下载链接：http://archive.apache.org/dist/kafka/此处我下载的版本是kafka_2.12-3.2.0，这个版本需要将参数替代原先的参数，否则执行命令会报错： 1.2 启动内置Zookeeper 1.3 启动Kafka 1.4 常用Kafka指令 创建topic 删除topic 查看所有的topic 向topic中
Flink之Redis的安装及RedisSink的用法
影子
03-11 1522
maven： <dependency> <groupId>org.apache.bahir</groupId> <artifactId>flink-connector-redis_2.11</artifactId> <version>1.0</version> </dependency> redis是key-value的形式存储。 redis的安装： 编译安装redis到
Flink sink算子，kafka数据写入redis
热门推荐
不是一枚开发
05-20 2万+
1. 概述   Redis 提供了string、hash、list、set、sorted set、bitmap等一系列常用的数据结构。 Flink 没有直接提供官方的 Redis 连接器，但 Bahir 项目提供了 Flink-Redis 的连接工具 2. 使用 2.1 引入依赖    服务器上的flink版本与引入的依赖之间有冲突，使用exclusions排除 <dependency> <groupId>org.apache.bahir</groupId
Flink流处理-Redis Connector
孙大圣的博客
12-19 4479
环境 flink-1.9.0 redis-5.0.4单机模式 一、需要的依赖 <!--flink流处理依赖--> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-streaming-java_2.11</artifactId>...
flink建模工具有哪些
08-05
### 回答1： Apache Flink 是一个开源的流处理框架，主要用于分布式数据处理。虽然 Flink 自身并没有提供专门的建模工具，但是可以通过 Flink 自带的 API 或者第三方工具来实现建模。 下面是一些 Flink 建模工具的示例： 1. Flink ML：Flink ML 是一个基于 Flink 的机器学习库，提供了一系列的算法和工具，包括分类、回归、聚类、推荐系统等。Flink ML 提供了多种建模算法和接口，可以直接在 Flink 上进行数据分析和建模。 2. Flink Gelly：Flink Gelly 是 Flink 的图处理库，可以用于分析和处理大规模图数据。Flink Gelly 提供了丰富的图算法和工具，包括 PageRank、连通性分析、最短路径、聚类等。Flink Gelly 可以用于构建基于图数据的模型。 3. Flink CEP：Flink CEP 是 Flink 的复杂事件处理库，用于在流数据中检测和处理符合一定模式的事件序列。Flink CEP 可以用于构建复杂事件模型和处理。 4. 第三方工具：除了 Flink 自带的库和工具之外，还可以使用其他第三方工具进行建模，比如 Apache Spark、TensorFlow、Scikit-learn 等。 需要注意的是，Flink 并不是一个专门用于建模的工具，而是一个用于流处理的框架。因此，Flink 的建模能力相对于专门的建模工具可能会有一定的限制，但是在流处理方面具有很高的灵活性和可扩展性。 ### 回答2： Flink 是一个流式计算框架，它提供了多种建模工具来帮助用户实现复杂的实时数据流处理任务。以下是几个常用的 Flink 建模工具： 1. Flink DataStream API：这是 Flink 中最基本也是最常用的建模工具，它是针对无界数据流的建模工具，提供了丰富的操作符来进行数据转换和处理。用户可以使用 DataStream API 来定义数据源、定义数据转换操作，并最终将结果输出到目标或者存储系统中。 2. Flink Table API：这是 Flink 提供的一种更高级抽象的建模工具，它基于关系型数据表的概念，提供了类似于 SQL 的语法和操作符，使用户能够以更简洁的方式定义和操作数据流。Table API 支持批处理和流处理，并可以与 DataStream API 进行无缝集成。 3. Flink SQL：这是 Flink 的另一种建模工具，它允许用户使用标准的 SQL 语法来对数据流进行查询和分析。用户只需将 SQL 语句提交给 Flink，Flink 就会自动将其翻译为底层的 DataStream 或 Table 程序，并执行相应的计算。 4. CEP 库：Flink 提供了支持复杂事件处理（Complex Event Processing，CEP）的库，用于识别和处理满足特定模式的事件序列。用户可以使用 CEP 库来构建复杂的事件模式，并定义相应的动作来响应满足该模式的事件。 总之，Flink 提供了多种建模工具，如 DataStream API、Table API、SQL 和 CEP 库等，使用户能够根据自己的需求选择合适的工具来实现实时数据流处理任务。 ### 回答3： Flink建模工具是Apache Flink提供的一系列用于实现数据处理和分析的可扩展、灵活的工具。以下是常见的Flink建模工具： 1. Flink Table API和SQL：Flink Table API和SQL是Flink提供的高级API，用于以关系型的思维进行数据处理和分析。它们提供了一种声明式的编程方式，允许用户通过类SQL语句或Table API的方法链式调用来实现数据转换、过滤、聚合等操作。 2. DataStream API：Flink的DataStream API是一种低级别的编程接口，用于处理无界流数据。它提供了丰富的操作符和函数，允许用户对流数据进行各种转换、过滤和计算。 3. DataSet API：Flink的DataSet API是一种用于处理有界数据集的编程接口。与DataStream API不同，DataSet API主要用于批处理场景，适用于离线计算和批量数据处理。 4. Flink Gelly：Flink Gelly是Flink的图处理库，提供了一套用于图计算的API和算法，如图的遍历、转换、聚合和迭代计算等。 5. Flink CEP：Flink CEP是Flink的复杂事件处理库，用于检测和处理复杂事件模式。它提供了一套用于定义事件模式、匹配事件以及执行相关操作的API和算法。 6. Flink ML：Flink ML是基于Flink的机器学习库，用于实现分布式的机器学习算法和模型训练。它提供了各种常见的机器学习算法，如线性回归、逻辑回归、决策树等。 这些都是Flink建模工具的常见组件，用户可以根据自己的需求选择适合的工具来建模和实现数据处理和分析任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

电光闪烁

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值