Nifi自定义处理器如何获取redis的db连接并重用该连接

我使用Nifi查询redis服务器上的地理空间数据。但是一旦我停止处理器，我查询的密钥就会被删除

我想在处理器中创建并重用redis连接

但该代码在普通java类中工作，如果我运行该代码，则密钥不会删除

我不明白为什么钥匙会被删除。以下是redis地理空间数据的自定义处理器代码

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.test.redis;


import org.apache.nifi.components.PropertyDescriptor;
import org.apache.nifi.flowfile.FlowFile;
import org.apache.nifi.annotation.behavior.ReadsAttribute;
import org.apache.nifi.annotation.behavior.ReadsAttributes;
import org.apache.nifi.annotation.behavior.WritesAttribute;
import org.apache.nifi.annotation.behavior.WritesAttributes;
import org.apache.nifi.annotation.lifecycle.OnScheduled;
import org.apache.nifi.annotation.lifecycle.OnStopped;
import org.apache.nifi.annotation.documentation.CapabilityDescription;
import org.apache.nifi.annotation.documentation.SeeAlso;
import org.apache.nifi.annotation.documentation.Tags;
import org.apache.nifi.processor.exception.ProcessException;
import org.apache.nifi.processor.AbstractProcessor;
import org.apache.nifi.processor.ProcessContext;
import org.apache.nifi.processor.ProcessSession;
import org.apache.nifi.processor.ProcessorInitializationContext;
import org.apache.nifi.processor.Relationship;
import org.apache.nifi.processor.util.StandardValidators;

import redis.clients.jedis.GeoRadiusResponse;
import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.params.GeoRadiusParam;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Tags({"example"})
@CapabilityDescription("Provide a description")
@SeeAlso({})
@ReadsAttributes({@ReadsAttribute(attribute="", description="")})
@WritesAttributes({@WritesAttribute(attribute="", description="")})
public class IotHubRedis extends AbstractProcessor {

    private volatile Jedis jedisPool;


    public static final PropertyDescriptor ConnectionHost = new PropertyDescriptor
            .Builder().name("ConnectionHost")
            .displayName("ConnectionHost")
            .description("ConnectionHost")
            .required(true)
            .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
            .build();
    public static final PropertyDescriptor ConnectionPort = new PropertyDescriptor
            .Builder().name("ConnectionPort")
            .displayName("ConnectionPort")
            .description("ConnectionPort")
            .required(true)
            .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
            .build();

    public static final PropertyDescriptor Radius = new PropertyDescriptor
            .Builder().name("Radius")
            .displayName("Radius")
            .description("Radius")
            .required(true)
            .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
            .build();


      public static final PropertyDescriptor Lattitude = new PropertyDescriptor
      .Builder().name("Lattitude") .displayName("Lattitude")
      .description("Lattitude") .required(true)
      .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
      .expressionLanguageSupported(true) .build();


      public static final PropertyDescriptor Longitude = new PropertyDescriptor
      .Builder().name("Longitude") .displayName("Longitude")
      .description("Longitude") .required(true)
      .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
      .expressionLanguageSupported(true) .build();


    public static final PropertyDescriptor RedisKey = new PropertyDescriptor
            .Builder().name("RedisKey")
            .displayName("RedisKey")
            .description("RedisKey")
            .required(true)
            .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
            .build();

    public static final Relationship Success = new Relationship.Builder()
            .name("Success")
            .description("Success")
            .build();

    public static final Relationship Failure = new Relationship.Builder()
            .name("Failure")
            .description("Failure")
            .build();

    private List<PropertyDescriptor> descriptors;

    private Set<Relationship> relationships;

    @Override
    protected void init(final ProcessorInitializationContext context) {
        final List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
        descriptors.add(ConnectionHost);
        descriptors.add(ConnectionPort);
        descriptors.add(Radius);
        descriptors.add(Lattitude);
        descriptors.add(Longitude);
        descriptors.add(RedisKey);
        this.descriptors = Collections.unmodifiableList(descriptors);

        final Set<Relationship> relationships = new HashSet<Relationship>();
        relationships.add(Success);
        relationships.add(Failure);
        this.relationships = Collections.unmodifiableSet(relationships);


    }

    @Override
    public Set<Relationship> getRelationships() {
        return this.relationships;
    }

    @Override
    public final List<PropertyDescriptor> getSupportedPropertyDescriptors() {
        return descriptors;
    }

    @OnScheduled
    public void onScheduled(final ProcessContext context) {
        try {
            //jedisPool = new Jedis(context.getProperty("ConnectionHost").toString(), Integer.parseInt(context.getProperty("ConnectionPort").toString()));
            //getLogger().info("----->Redis Connection is Successful"+jedisPool);
            jedisPool = new Jedis("192.168.8.214",6379);
        } catch (Exception e) {
            getLogger().error("Unable to establish Redis connection pool.");
        }

    }

    @OnStopped
    public void closeRedisPool(final ProcessContext context) {
        jedisPool.flushAll();
        jedisPool.close();
    }


    @Override
    public void onTrigger(final ProcessContext context, final ProcessSession session) throws ProcessException {
        FlowFile flowFile = session.get();
        Double lat=Double.parseDouble(context.getProperty("Lattitude").evaluateAttributeExpressions(flowFile).getValue().toString());
        Double lon=Double.parseDouble(context.getProperty("Longitude").evaluateAttributeExpressions(flowFile).getValue().toString());
        String location="NA";
        Double geoRadiusInKm=Double.parseDouble(context.getProperty("Radius").toString());
        String RedisKey=context.getProperty("RedisKey").toString();
        if ( flowFile == null ) {
            return;
        }

        else {
            try {

                if(!(lat==null || lat==null|| lat.equals("") || lon.equals(""))) {
                GeoRadiusParam param = GeoRadiusParam.geoRadiusParam();
                param.withDist().sortAscending().count(1);
                 List<GeoRadiusResponse> georadius2 = jedisPool.georadius(RedisKey.toString().getBytes(),lat, lon, geoRadiusInKm, GeoUnit.KM, param);
                 //flowFile = session.putAttribute(flowFile, "connection1", "------------>"+RedisKey+"=="+lat+"=="+lon+"=="+geoRadiusInKm+"=="+param);
                 if (!georadius2.isEmpty()) {
                    for (GeoRadiusResponse geoRadiusResponse : georadius2) {
                                    location = geoRadiusResponse.getMemberByString();
                    }
                    flowFile = session.putAttribute(flowFile, "msg", "------------>if block inside try");
                    flowFile = session.putAttribute(flowFile, "location", location);
                    session.transfer(flowFile, Success);
                }
                else {
                    flowFile = session.putAttribute(flowFile, "msg", "------------>else georadius2 is empty");
                    flowFile = session.putAttribute(flowFile, "location", location);
                    session.transfer(flowFile, Success);
                }
            }
                else {
                    flowFile = session.putAttribute(flowFile, "msg", "------------>lat lon null or empty");
                    flowFile = session.putAttribute(flowFile, "location", location);
                    session.transfer(flowFile, Success);
                }


        }
            catch (JedisConnectionException e) { 
                session.transfer(flowFile, Success);

            }
        // TODO implement
    }

}
}

/*
*根据一个或多个许可证颁发给Apache软件基金会（ASF）
*贡献者许可协议。请参阅随附的通知文件
*本作品提供了有关版权所有权的更多信息。
*ASF根据Apache许可证2.0版将此文件许可给您
*（以下简称“许可证”）；除非符合以下要求，否则不得使用此文件
*执照。您可以通过以下方式获得许可证副本：
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
*除非适用法律要求或书面同意，软件
*根据许可证进行的分发是按“原样”进行分发的，
*无任何明示或暗示的保证或条件。
*请参阅许可证以了解管理权限和权限的特定语言
*许可证下的限制。
*/
包com.test.redis；
导入org.apache.nifi.components.PropertyDescriptor；
导入org.apache.nifi.flowfile.flowfile；
导入org.apache.nifi.annotation.behavior.ReadsAttribute；
导入org.apache.nifi.annotation.behavior.ReadsAttributes；
导入org.apache.nifi.annotation.behavior.WriteAttribute；
导入org.apache.nifi.annotation.behavior.WriteAttribute；
导入org.apache.nifi.annotation.lifecycle.OnScheduled；
导入org.apache.nifi.annotation.lifecycle.OnStopped；
导入org.apache.nifi.annotation.documentation.CapabilityDescription；
导入org.apache.nifi.annotation.documentation.see；
导入org.apache.nifi.annotation.documentation.Tags；
导入org.apache.nifi.processor.exception.ProcessException；
导入org.apache.nifi.processor.AbstractProcessor；
导入org.apache.nifi.processor.ProcessContext；
导入org.apache.nifi.processor.ProcessSession；
导入org.apache.nifi.processor.ProcessorInitializationContext；
导入org.apache.nifi.processor.Relationship；
导入org.apache.nifi.processor.util.StandardValidators；
导入redis.clients.jedis.GeoRadiusResponse；
导入redis.clients.jedis.GeoUnit；
导入redis.clients.jedis.jedis；
导入redis.clients.jedis.JedisPool；
导入redis.clients.jedis.jedis.config；
导入redis.clients.jedis.exceptions.JedisConnectionException；
导入redis.clients.jedis.params.GeoRadiusParam；
导入java.net.URI；
导入java.net.URISyntaxException；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
@标记（{“示例”}）
@能力描述（“提供说明”）
@另见（{}）
@ReadsAttributes（{@ReadsAttribute（attribute=，description=）}）
@WriteAttribute（{@WriteAttribute（attribute=“”，description=“”）}）
公共类IoTubRedis扩展了AbstractProcessor{
私人易变绝地武士；
公共静态最终PropertyDescriptor ConnectionHost=新PropertyDescriptor
.Builder（）.name（“ConnectionHost”）
.displayName（“连接主机”）
.说明（“连接主机”）
。必需（正确）
.addValidator（标准验证器。非空验证器）
.build（）；
公共静态最终PropertyDescriptor ConnectionPort=新PropertyDescriptor
.Builder（）.name（“连接端口”）
.displayName（“连接端口”）
.说明（“连接端口”）
。必需（正确）
.addValidator（标准验证器。非空验证器）
.build（）；
公共静态最终PropertyDescriptor半径=新PropertyDescriptor
.Builder（）.name（“半径”）
.displayName（“半径”）
.说明（“半径”）
。必需（正确）
.addValidator（标准验证器。非空验证器）
.build（）；
公共静态最终PropertyDescriptor Lattude=新PropertyDescriptor
.Builder（）.name（“latitude”）.displayName（“latitude”）
.说明（“Lattitude”）。必填项（正确）
.addValidator（标准验证器。非空验证器）
.expressionLanguageSupported（true）.build（）；
公共静态最终PropertyDescriptor经度=新PropertyDescriptor
.Builder（）.name（“经度”）.displayName（“经度”）
.说明（“经度”）。必填项（真）
.addValidator（标准验证器。非空验证器）
.expressionLanguageSupported（true）.build（）；
public static final PropertyDescriptor RedisKey=new PropertyDescriptor
.Builder（）.name（“RedisKey”）
.displayName（“重新键”）
.说明（“重新索引”）
。必需（正确）
.addValidator（标准验证器。非空验证器）
.build（）；
public static final Relationship Success=新建Relationship.Builder（）
.姓名（“成功”）
.说明（“成功”）
.build（）；
公共静态最终关系失败=新建关系.Builder（）
.名称（“失败”）
.说明（“失败”）
.build（）；
私有列表描述符；
私人关系；
@凌驾
受保护的void init（最终ProcessorInitializationContext上下文）{
最终列表描述符=新的ArrayList（）；
描述符。添加（ConnectionHost）；
描述符。添加（连接端口）；
描述符。添加（半径）；
描述符。添加（格度）；
描述符。添加（经度）；
描述符。添加（重新索引）；
this.descriptors=Collections.unmodifiableList（描述符）；
最终集关系=新HashSet（）；
关系。添加（成功）；
添加（失败）；
这个关系=集合
FlowFile flowFile = session.get();
// Doing something with flowfile
if ( flowFile == null ) {
    return;
}