反射解析数据格式

package org.flink.source;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;
import java.util.concurrent.TimeUnit;

import org.apache.flink.api.common.ExecutionConfig;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.serialization.TypeInformationSerializationSchema;
import org.apache.flink.api.common.time.Time;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.typeutils.RowTypeInfo;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer011;
import org.apache.flink.streaming.connectors.kafka.internals.KeyedSerializationSchemaWrapper;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.types.Row;
import org.flink.source.mileData.mileDatatest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ReflectionUtils;

import com.google.protobuf.InvalidProtocolBufferException;
import com.twitter.chill.protobuf.ProtobufSerializer;

/**
 * @Package org.flink.kafkaservice
 * @Description: TODO
 * @author wangshumin
 * @date 2019年12月14日 上午11:37:18
 * @version V1.0
 */
public class KafkaToTable2 {
    private static final Logger log = LoggerFactory.getLogger(KafkaToTable2.class);
    private static final String sourceTopic = "topicE";
    private static final String groupid = "etl5";
    private static final String kafka_host = "192.168.152.214:9092";

    static int failureRate = 3;// 一个时间段内的最大失败次数
    static Time failureInterval = Time.of(5, TimeUnit.MINUTES);// 衡量失败次数的是时间段
    static Time delayInterval = Time.of(10, TimeUnit.SECONDS);// 间隔
    

    @SuppressWarnings("rawtypes")
    public static void main(String[] args) throws Exception {
         StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
         //register the Google Protobuf serializer with Kryo
         env.getConfig().registerTypeWithKryoSerializer(mileData.class, ProtobufSerializer.class);
         env.setParallelism(1);
         StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
         String[] fieldNames = new String[] {"startTime","receiveTime","rotarySpeed","pulseSpeed","mile"};
         TypeInformation[] types= new TypeInformation[]{Types.LONG,Types.LONG,Types.INT,Types.INT,Types.DOUBLE}; 
         RowTypeInfo rowTypeInfo = new  RowTypeInfo(types, fieldNames);
         //TypeInformation<Row> typeInfo = Types.ROW_NAMED(fieldNames, types);
       
        Properties properties = new Properties();
        properties.setProperty("group.id", groupid);
        properties.setProperty("bootstrap.servers", kafka_host);

        TypeInformation<byte[]> typeInfo=TypeInformation.of(byte[].class);
        TypeInformationSerializationSchema<byte[]> deserializationSchema = new TypeInformationSerializationSchema<byte[]>(typeInfo, new ExecutionConfig());
        
        
        
        FlinkKafkaConsumer011<byte[]> myConsumer = new FlinkKafkaConsumer011<>(sourceTopic,deserializationSchema, properties);
        /*
         * 默认读取上次保存的offset信息
         * 如果是应用第一次启动，读取不到上次的offset信息，则会根据这个参数auto.offset.reset的值来进行消费数据
         */
        //myConsumer.setStartFromGroupOffsets();
        myConsumer.setStartFromEarliest();
        myConsumer.setCommitOffsetsOnCheckpoints(true);

        DataStream<byte[]> kafkaData = env.addSource(myConsumer).setParallelism(1).uid("kafkaData-id");

        SingleOutputStreamOperator<Row> kafkaStreamData = kafkaData.map(new MapFunction<byte[],Row>() {

                 public Row  map(byte[] value) throws InvalidProtocolBufferException, Exception {
                     Class<?> mileDatatestclazz =null ;
                     //mileDatatest parseFrom = mileData.mileDatatest.parseFrom(value);
                     //org.flink.source.mileData.mileDatatest mileDatatest =null ;
                     Object mileDatatest =null ;
                     Object emtpyMileDatatest =null ;
                     try {
                         mileDatatestclazz = Class.forName("org.flink.source.mileData$mileDatatest");
                         //String fullClassName = mileDatatestclazz.getName().replace("$", ".");
                         //System.err.println(fullClassName);
                         Method getDefaultInstance = ReflectionUtils.findMethod(mileDatatestclazz,"getDefaultInstance");
                         emtpyMileDatatest =  ReflectionUtils.invokeMethod(getDefaultInstance, value);
                            Method parseFrom2 = ReflectionUtils.findMethod(mileDatatestclazz,"parseFrom",new Class[]{ byte[].class });
                         mileDatatest =  parseFrom2.invoke(emtpyMileDatatest, value);
                     } catch (ClassNotFoundException e) {
                         e.printStackTrace();
                     }
                      Row row =  new Row(5);
                      Method getStartTime = ReflectionUtils.findMethod(mileDatatestclazz,"getStartTime");
                      Method getReceiveTime = ReflectionUtils.findMethod(mileDatatestclazz,"getReceiveTime");
                      Method getPulseSpeed = ReflectionUtils.findMethod(mileDatatestclazz,"getPulseSpeed");
                      Method getRotarySpeed = ReflectionUtils.findMethod(mileDatatestclazz,"getRotarySpeed");
                      Method getMile = ReflectionUtils.findMethod(mileDatatestclazz,"getMile");
                     
                      row.setField(0, getStartTime.invoke(mileDatatest));
                      row.setField(1, getReceiveTime.invoke(mileDatatest));
                      row.setField(2, getPulseSpeed.invoke(mileDatatest));
                      row.setField(3, getRotarySpeed.invoke(mileDatatest));
                      row.setField(4, getMile.invoke(mileDatatest));

                      
                     System.err.println("--invokerow-"+row);

                      
                      
//                     for (int i = 0; i < serializedSize; i++) {
//                        row.setField(i, fields.get(i).getDefaultValue());
//                    }
//                     for (Entry<FieldDescriptor, Object> entry : allFields.entrySet()) {
//                         Object field = parseFrom.getField(entry.getKey());
//                         Type type = entry.getKey().getType();
//                         System.err.println(type+"--"+field);
                    /*
                     * Type type = entry.getKey().getType(); Object value2 = entry.getValue();
                     */
                         //System.err.println(type+"--"+value2);
                    //}
                     //System.err.println(parseFrom.toString());
                     //String[] mYvalue = value.toString().split(",");
                     //long receiveTime = parseFrom.getReceiveTime();
                     //System.err.println(Arrays.asList(receiveTime));
                      //int length = mYvalue.length;
//                      Row row = new  Row(serializedSize);
//                      for (int i = 0; i < serializedSize; i++) {
//                        Object objectValue = null ;
//                        if (types[i].equals(Types.STRING)) {
//                            objectValue = parseFrom.;
//                        }
//                        if (types[i].equals(Types.LONG)) {
//                            //System.err.println(mYvalue[i].trim());
//                            objectValue = Long.valueOf(mYvalue[i].trim());
//                        }
//                        if (types[i].equals(Types.INT)) {
//                            objectValue = Integer.valueOf(mYvalue[i].trim());
//                        }
//                        if (types[i].equals(Types.DOUBLE)) {
//                            objectValue = Double.valueOf(mYvalue[i].trim());
//                        }
//                        row.setField(i, objectValue);
//                    }
                     //log.info(String.format("accept-context:%s", row));
                     return row ;
                 }
             }).setParallelism(1).uid("uidflatMap").returns(rowTypeInfo);

          Table kafkaStreamDataT1 = tableEnv.fromDataStream(kafkaStreamData);
          
          tableEnv.registerTable("T1",kafkaStreamDataT1);
          
          String sql1 = "select startTime, rotarySpeed, mile from T1 ";
          
          Table T2 = tableEnv.sqlQuery(sql1);
          
          tableEnv.registerTable("T2",T2);
          T2.printSchema();
          DataStream<Row> result = tableEnv.toAppendStream(T2, Row.class);        
          //result.print();
          DataStream<Row> streamResult = result.map(new MapFunction<Row, Row>() {
                @Override
                public Row map(Row value) throws Exception {
                    //log.info(String.format("accept-context:%s", value));
                    return value;
                }
            });

        //streamResult.print();
        TypeInformation<Row> typeInfo1 = TypeInformation.of(Row.class);
        TypeInformationSerializationSchema<Row> serializationSchema = new TypeInformationSerializationSchema<Row>(
                typeInfo1, new ExecutionConfig());
        FlinkKafkaProducer011<Row> myProducer = new FlinkKafkaProducer011<Row>("topic-table",
                new KeyedSerializationSchemaWrapper<Row>(serializationSchema), properties,
                FlinkKafkaProducer011.Semantic.EXACTLY_ONCE);

        // 定义生产者是否应因为错误而失败，或只记录他们。
        // 如果设置为true，则只记录异常，
        // 如果设置为false ,最终会抛出异常，导致流程序失败(并进入恢复)。
        myProducer.setLogFailuresOnly(false);
        // 如果设置为true, Flink将把附加到每个记录的(事件时间)时间戳写入Kafka。
        // 时间戳必须是正确的，Kafka才能接受它们。
        myProducer.setWriteTimestampToKafka(true);
        
        streamResult.addSink(myProducer).name("sinkkkafka");

        env.execute("Flink Table Engine");

    }

}