精华内容
下载资源
问答
  • 典型综合场景数据流转设计 综合场景一 T+1数据加工 图 4 T+1方式数据流转   T+1是数据仓库领域最为常见的数据集成模式,T+1模式下数据仓库会在每天固定时间点采集当天或者前一天交易系统数据。 根据数据...

     

    典型综合场景数据流转设计

    综合场景一 T+1数据加工

    图 4 T+1方式数据流转

     

    T+1是数据仓库领域最为常见的数据集成模式,T+1模式下数据仓库会在每天固定时间点采集当天或者前一天交易系统数据。

    根据数据类型,结构化数据来源一般为RDB,需要将这些数据通过ETL工具全量或者增量导入到tdh的hdfs中,最后根据实际业务需求通过inceptor将数据写入到对应的表中:

    ① sqoop/tdt支持全量/增量导入数据,可以装载到hdfs中,tdt可以直接写入orc表中。

    ② 需要做大量聚合分析的写入orc表或者argodb表,有数据合并、删除、修改操作的写入orc事务表;高并发的精确查询写入hyperbase表;精确查询、模糊查询、多维度灵活组合查询写入Search表;

    有时候,结构化数据可以通过原系统导出成文本,放在FTP或者其他文件系统,这种文本可以类似日志、文档等外部数据一样,可以通过flume、Superput工具采集到HDFS,然后通过Inceptor写入合适的存储引擎。

     

    例一:

    oracle中的表 tableA,需要一次性的全量抽取全部数据,之后的业务需要对该表做精确查询。这个时候选择Transporter直接将数据录入orc表中,之后根据业务的需求,将数据录入hyperbase中。

     

    例二:

    oracle中的表tableA,该表每日有数据录入,需要对该表的数据做统计分析。这个时候可以选择sqoop对该表进行增量数据的抽取,放在HDFS上,之后通过inceptor将数据存入Argodb中,方便之后的统计分析。

     

    例三:

    每日的系统日志文件,需要根据日志进行ERROR的分析。选用flume对日志的目录进行数据采集,之后通过将数据存入Search中对日志信息进行分词,方便针对报错信息的排查。

     

    例四:

    超大量的离线历史数据文件,需要放入大数据平台存储。选用Superput将数据上传进hdfs进行存储。

     

    综合场景二 准实时数据同步

    图 5 准实时同步数据流转

     

    越来越多数据仓库向准实时方向演进。

    Oracle/DB2可以通过部署ogg/CDC+Transporter,实现准实时地将数据录入到tdh集群中,mysql特殊一些,可以基于binlog实现。之后根据业务需求参考上文图三选择合适的目标表:数据集市场景可以使用ArgoDB,高并发精确检索使用Hyperbase,综合搜索选择Search。

     

    例一:

    Oracle中的数据需要准实时的将数据同步写入大数据平台中。搭建一套ogg+transporter的方式,可以将数据准实时的录入到orc事务表中。

     

    例二:

    Mysql中的数据需要准实时的将数据同步写入到大数据平台中。这边有很多的工具都可以直接将mysql数据同步到hdfs中,这边推荐使用CDC或者MySQL Applier for Hadoop。

     

     

    综合场景三 实时流处理

    图 6 实时数据流转

     

    比较多的情况下实时数据通过kakfa接入,数据来源可以是kafka producer/flume等,经过slipstream的处理,之后根据实际业务需求,将数据入库到TDH中

    ① 处理后的数据再次进入kafka,之后对数据在进一步处理,这样的情况一般是kafka作为数据总线的情况,不同的业务通过slipstream去不断地和kafka进行数据上的交互

    ② 经过slipstream处理后录入到Search/Hyperbase/Argodb的数据可以继续通过Inceptor将表改变成其他格式,方便其他业务场景的需求,这时候就可以参考上文图三选择合适的目标表了。

     

    例一:

    实时数据通过kafka进来,需要在经过处理后把结果实时显示在大屏上。这个时候的kafka担任着数据总线的功能,数据从kafka接入,通过slipstream处理后再输出给kafka。下游大屏显示工具实时消费kafka数据。

     

    例二:

    实施数据通过kafka进来,对结果需要进行统计分析和批处理。可以通过Slipstream接入数据到hyperbase表,之后再通过inceptor或者Hyperbase API,将数据流转到Inceptor ORC表中,从而满足业务需求。

     

    上面抽象的三种典型数据流转综合场景,其原理是非常一致的:数据通过工具接入,根据业务需求,选择写入合适的表。

    实际项目中的数据流转设计相关负责一些,数据源、客户需求变化很多,但是万变不离其宗,大家充分掌握平台组件的技术特点和原理,并且深入理解客户需求,再加以练习实践,设计数据流转其实并不难。

    下面是一个经典的项目数据流转方案,可以做为练习和实践的参考案例:

    图 7 经典数据流转方案

    展开全文
  • 设计两个可综合的电路模块:第一个模块(M1)接受四位并行数据,并将其转化为简化I2C传输格式。sclk为输入主钟,data[3:0]为输入的四位数据,ack为请求发送数据信号(请求后才有数据发送到data[3:0]),数据流用scl...

           设计两个可综合的电路模块:第一个模块(M1)接受四位并行数据,并将其转化为简化I2C传输格式。sclk为输入主钟,data[3:0]为输入的四位数据,ack为请求发送数据信号(请求后才有数据发送到data[3:0]),数据流用scl和sda两条线传输。第二个模块(M2)接收以简化I2C协议通过scl和sda传输来的数据,并转化为相应16条信号线上的高电平,若数据为1,则第一条线路为高电平,数据为n,则第N条线路为高电平。模块如下图所示。

            本文引用自https://blog.csdn.net/llxxyy507/article/details/81046981


           简化的I2C通信协议如下:scl为时钟信号,当scl为高电平的时候,sda从高电平变为低电平,表示串行数据流开始传输;当scl为高电平,sda从低电平变为高电平的时候,表示串行数据流结束。sda信号只能在scl为低电平的时候变化,在scl为高电平期间应该维持稳定。


           上图中,sda信号在scl为高时从高变低,为数据流的开始。在scl为低电平时传输第一位数据(MSB),并在整个scl为高的期间都维持信号的稳定,接着传递剩下的数据。sda信号在scl为高时从低变高,表示数据流的结束。

           模块M1的verilog代码(ptosda.v)如下:

    module ptosda(sclk,rst,data,ack,scl,sda);
    input sclk,rst,data;
    wire [3:0]data;
    
    output scl,sda,ack;
    reg scl,ack,link_sda,sdabuf;
    reg [3:0]databuf;
    reg [7:0]state;
    
    out16hi m2(.scl(scl), .sda(sda), .outhigh() );    //调用M2模块
    
    assign  sda = link_sda ? sdabuf : 1'b0;        //link_sda控制sdabuf输出到串行总线上
    
    parameter  ready  =  8'b0000_0000,
               start  =  8'b0000_0001,
               bit1   =  8'b0000_0010,
               bit2   =  8'b0000_0100,
               bit3   =  8'b0000_1000,
               bit4   =  8'b0001_0000,
               bit5   =  8'b0010_0000,
               stop   =  8'b0100_0000,
               IDLE   =  8'b1000_0000;
    
    always @(posedge sclk or negedge rst)         //主钟sclk产生串行输出时钟clk
           begin
                  if (!rst)
                    scl <= 1;
                  else
                    scl <= ~scl;
           end
    
    always @(posedge ack)
           databuf <= data;
    
    always @(negedge sclk or negedge rst)
           if (!rst)
               begin
                     link_sda <= 0;
                     state <= ready;
                     sdabuf <= 1;
                     ack <= 0;
               end
            else  
               begin
                  case(state)
                  ready : if(ack) 
                            begin 
                               link_sda <= 1;
                               state <= start;
                            end
                          else
                            begin
                               link_sda <= 0;
                               state <= ready;
                               ack <= 1;
                            end
                   
                   start : if(scl && ack)
                             begin 
                                sdabuf <= 0;
                                state <= bit1;
                             end
                           else
                             state <= start;
    
                    bit1  : if(!scl)
                              begin
                                 sdabuf <= databuf[3];
                                 state <= bit2;
                                 ack <= 0;
                              end
                             else
                              state <= bit1;
                                
                    bit2  : if(!scl)
                              begin
                                 sdabuf <= databuf[2];
                                 state <= bit3;
                              end
                             else
                              state <= bit2;
                                
                    bit3  : if(!scl)
                              begin
                                 sdabuf <= databuf[1];
                                 state <= bit4;
                              end
                             else
                              state <= bit3;
                                
                    bit4  : if(!scl)
                              begin
                                 sdabuf <= databuf[0];
                                 state <= bit5;
                              end
                             else
                              state <= bit4;
                                
                    bit5  : if(!scl)
                              begin
                                 sdabuf <= 0;
                                 state <= stop;
                              end
                             else
                              state <= bit5;
                                
                    stop  : if(scl)
                              begin
                                 sdabuf <= 1;
                                 state <= IDLE;
                              end
                             else
                              state <= stop;
                                
                    IDLE  :  begin
                                 link_sda <= 0;
                                 state <= ready;
                              end
                                
                   default  : begin
                                 link_sda <= 0;
                                 sdabuf <= 1;
                                state <= ready;
                              end
                 endcase
              end
    endmodule
    

            模块M2(out16hi.v)verilog代码如下:

    module out16hi(scl,sda,outhigh);
    input scl,sda;
    output [15:0]outhigh;
    
    reg [4:0]mstate;
    reg [3:0]pdata,pdatabuf;
    reg [15:0]outhigh;
    reg StartFlag,EndFlag;              //串行数据开始和结束标志
    
    always @(negedge sda)
         begin
           if (scl)
               StartFlag <= 1;
           else if (EndFlag)
               StartFlag <= 0;
         end
    
    always @(posedge sda)
           if (scl)
              begin
                EndFlag <= 1;
    				pdatabuf <= pdata;
              end
           else
                EndFlag <= 0;
           
    parameter sbit0 = 5'b0_0001,
              sbit1 = 5'b0_0010,
              sbit2 = 5'b0_0100,
              sbit3 = 5'b0_1000,
              sbit4 = 5'b1_0000;
    
    always @(pdatabuf)                              //接受到的数据转化为相应的输出位的高电平
           begin
             case(pdatabuf)
                 4'b0001: outhigh = 16'b0000_0000_0000_0001; 
                 4'b0010: outhigh = 16'b0000_0000_0000_0010; 
                 4'b0011: outhigh = 16'b0000_0000_0000_0100; 
                 4'b0100: outhigh = 16'b0000_0000_0000_1000; 
                 4'b0101: outhigh = 16'b0000_0000_0001_0000; 
                 4'b0110: outhigh = 16'b0000_0000_0010_0000; 
                 4'b0111: outhigh = 16'b0000_0000_0100_0000; 
                 4'b1000: outhigh = 16'b0000_0000_1000_0000; 
                 4'b1001: outhigh = 16'b0000_0001_0000_0000; 
                 4'b1010: outhigh = 16'b0000_0010_0000_0000; 
                 4'b1011: outhigh = 16'b0000_0100_0000_0000; 
                 4'b1100: outhigh = 16'b0000_1000_0000_0000; 
                 4'b1101: outhigh = 16'b0001_0000_0000_0000; 
                 4'b1110: outhigh = 16'b0010_0000_0000_0000; 
                 4'b1111: outhigh = 16'b0100_0000_0000_0000; 
                 4'b0000: outhigh = 16'b1000_0000_0000_0000; 
              endcase
             end
    
    always @(posedge scl)
           if (StartFlag)
              case(mstate)
                  sbit0 : begin
                            mstate <= sbit1;
                            pdata[3] <= sda;
                          end
    
                  sbit1 : begin
                            mstate <= sbit2;
                            pdata[2] <= sda;
                          end
    
                  sbit2 : begin
                            mstate <= sbit3;
                            pdata[1] <= sda;
                          end
    
                  sbit3 : begin
                            mstate <= sbit4;
                            pdata[0] <= sda;
                          end
    
                  sbit4 : begin
                            mstate <= sbit0;
                          end
     
                  default : mstate <= sbit0;
    
               endcase
          else   mstate <= sbit0;
    endmodule
    
    

    testbench文件(sigdata_test.v)内容如下:

    `timescale 1ns/1ns
    `define halfperiod 50
    
    module sigdata_test(rst,sclk,data,ack_for_data,sda,scl,outhigh);
    output rst;
    output [3:0]data;
    output sclk;
    input ack_for_data;
    reg rst,sclk;
    reg [3:0]data;
    
    output sda,scl,outhigh;
    wire sda;
    wire scl;
    wire [15:0]outhigh;
    
    ptosda m1(.sclk(sclk), .rst(rst), .data(data), .ack(ack_for_data), .scl(scl), .sda(sda) );
    out16hi m2(scl,sda,outhigh);
    
    initial
          begin
              rst = 1;
            #10 rst = 0;
            #(`halfperiod*2+3) rst = 1;
          end
    
    initial
          begin
              sclk = 0;
              data = 0;
              #(`halfperiod*1000) $stop;
          end
    
    always #(`halfperiod) sclk = ~sclk;
    
    always @(posedge ack_for_data)
           begin
              #(`halfperiod/2 + 3) data = data + 1;
           end
    
    endmodule
    

            仿真的结果如下:


            加入中间变量查看结果得到如下,可以看出data[3:0]数据准确的传入到了pdatabuf[3:0],并通过outhigh准确输出了对应信号线的高电平。


    展开全文
  • end always @(posedge ack) //请求新数据时存入并行总线上要转换的数据 databuf ; /*主状态机:产生控制信号,根据databuf中保存的数据,按照协议产生sda串行信号*/ always @(negedge sclk or negedge rst) if(!...

    模块M0

    `timescale 1ns/100ps
    `define clk_cyc    50
    module sigdata(rst,data,sclk,ack);
    input        ack;
    output        rst;
    output    [3:0]    data;
    output        sclk;
    reg        rst;
    reg        sclk;
    reg    [3:0]    data;

    initial 
    begin
        rst <= 1;
        #10rst=0;
        #(`clk_cyc*2+3)rst=1;

    end
    initial
    begin
        sclk = 0;
        data = 0;
        #(`clk_cyc * 1000) $stop;
    end
    always #(`clk_cyc) sclk = ~sclk;
    always @(posedge ack)
    begin
        #(`clk_cyc/2+3) data = data+1;
    end
    endmodule
     

    模块M1
    module ptosda(rst,sclk,data,ack,scl,sda);
    input         rst,sclk;
    input    [3:0]    data;                //并行口数据输入
    output        ack;                //请求新的转换数据
    output        scl;                
    output        sda;                //定义SDA为单向的串行输出
    reg        ack;
    reg        scl;
    reg        link_sda;
    reg        sdabuf;
    reg    [3:0]    databuf;
    reg    [7:0]    state;

    assign    sda = link_sda?sdabuf:1'b0;        //link_sda控制sdabuf输出到串行总线上

    parameter     ready    = 8'b0000_0000,
            start    = 8'b0000_0001,
            bit3    = 8'b0000_0010,
            bit2    = 8'b0000_0100,
            bit1    = 8'b0000_1000,
            bit0    = 8'b0001_0000,
            prestop    = 8'b0010_0000,
            stop    = 8'b0100_0000,
            idle    = 8'b1000_0000;

    always@(posedge sclk or negedge rst)        //由输入的sclk产生串行输出时钟scl
    begin
        if(!rst)
            scl <= 1;
        else
            scl <= ~scl;
    end    
    always @(posedge ack)                //请求新数据时存入并行总线上要转换的数据
        databuf <= data;

    /*主状态机:产生控制信号,根据databuf中保存的数据,按照协议产生sda串行信号*/
    always @(negedge sclk or negedge rst)
        if(!rst)
        begin
            link_sda <= 0;            //把sdabuf与sda串行总线断开
            state     <= ready;
            sdabuf     <= 1;
            ack     <= 0;
        end
        else
        begin
            case(state)
                ready:
                    if(ack)
                    begin
                        link_sda <= 1;
                        state     <= start;
                    end
                    else
                    begin
                        link_sda <= 0;
                        state    <= ready;
                        ack    <= 1;        //请求新数据信号置为1
                    end
                start:
                    if(ack&&scl)
                    begin
                        sdabuf    <= 0;
                        state    <= bit3;
                    end
                    else
                    begin
                        state    <= start;
                    end
                bit3:
                    if(!scl)
                    begin
                        sdabuf    <= data[3];
                        state    <= bit2;
                        ack    <= 0;
                    end
                    else
                        state    <= bit3;
                bit2:
                    if(!scl)
                    begin
                        sdabuf    <= data[2];
                        state    <= bit1;
                    end
                    else
                        state    <= bit2;
                bit1:
                    if(!scl)
                    begin
                        sdabuf    <= data[1];
                        state    <= bit0;
                    end
                    else
                        state    <= bit1;
                bit0:
                    if(!scl)
                    begin
                        sdabuf    <= data[0];
                        state    <= prestop;
                    end
                    else
                        state    <= bit0;
                prestop:
                    if(!scl)
                    begin
                        sdabuf    <= 0;
                        state    <= stop;
                    end
                    else
                        state    <= prestop;
                stop:
                    if(scl)
                    begin
                        sdabuf    <= 1;
                        state    <= idle;
                    end
                    else
                        state    <=stop;
                idle:
                    begin
                        link_sda<= 0;
                        state    <= ready;
                    end
                default:
                    begin
                        link_sda<= 0;
                        sdabuf  <= 1;
                        state    <= ready;
                    end
            endcase
        end
    sigdata u0(.rst(rst),.data(data),.sclk(sclk),.ack(ack));
    endmodule

    模块M2

    module out16hign(scl,sda,outhigh);
    input         scl;
    input         sda;
    output    [15:0]     outhigh;
    reg    [5:0]    mstate;                //本模块的主状态
    reg    [3:0]    pdata,pdatabuf;            //用寄存器和最终数据寄存器记录串行数据位。
    reg    [15:0]    outhigh;            //输出位寄存器

    reg        Startflag,Endflag;        //数据开始和结束标记
    always@(negedge sda)
    begin
        if(scl)
            Startflag <= 1;
        else if(Endflag)
            Startflag <= 0;
    end

    always@(posedge sda)
        if (scl)
        begin
            Endflag <= 1;
            pdatabuf<= pdata;        //把收到的4位数据存入寄存器
        end
        else
            Endflag    <= 0;
    parameter
        ready    = 6'b00_0000,
        sbit0    = 6'b00_0001,
        sbit1    = 6'b00_0010,
        sbit2    = 6'b00_0100,
        sbit3    = 6'b00_1000,
        sbit4    = 6'b01_0000;
    always@(pdatabuf)
    begin
        case(pdatabuf)
            4'b0001:    outhigh = 16'b0000_0000_0000_0001;
            4'b0010:    outhigh = 16'b0000_0000_0000_0010;
            4'b0011:    outhigh = 16'b0000_0000_0000_0100;
            4'b0100:    outhigh = 16'b0000_0000_0000_1000;
            4'b0101:    outhigh = 16'b0000_0000_0001_0000;
            4'b0110:    outhigh = 16'b0000_0000_0010_0000;
            4'b0111:    outhigh = 16'b0000_0000_0100_0000;
            4'b1000:    outhigh = 16'b0000_0000_1000_0000;
            4'b1001:    outhigh = 16'b0000_0001_0000_0000;
            4'b1010:    outhigh = 16'b0000_0010_0000_0000;
            4'b1011:    outhigh = 16'b0000_0100_0000_0000;
            4'b1100:    outhigh = 16'b0000_1000_0000_0000;
            4'b1101:    outhigh = 16'b0001_0000_0000_0000;
            4'b1110:    outhigh = 16'b0010_0000_0000_0000;
            4'b1111:    outhigh = 16'b0100_0000_0000_0000;
            4'b0000:    outhigh = 16'b1000_0000_0000_0000;
        endcase
    end


    always@(posedge scl)
        if(Startflag)
            case(mstate)
                sbit0:
                begin
                    mstate  <=sbit1;
                    pdata[3]<=sda;
                    $display("i am in sdabit0");
                end
                sbit1:
                begin
                    mstate <= sbit2;
                    pdata[2]<= sda;
                    $display("i am in sdabit1");
                end
                sbit2:
                begin
                    mstate <= sbit3;
                    pdata[1]<= sda;
                    $display("i am in sdabit2");
                end
                sbit3:
                begin
                    mstate <= sbit4;
                    pdata[0]<= sda;
                    $display("i am in sdabit3");
                end
                sbit4:
                begin
                    mstate <= sbit0;
                    $display("i am in sdastop");
                end
                default:
                    mstate    <= sbit0;
            endcase
        else
            mstate <= sbit0;
    ptosda u1(.rst(rst),.sclk(sclk),.data(data),.ack(ack),.scl(scl),.sda(sda));
    endmodule
     

    展开全文
  • Yotta企业云盘帮助互联网软件企业实现数据安全管控和知识积累,提高信息共享和数据流转效率,让跨部门/跨区域的协作更加简单高效。 文件管理的行业困扰 1、存储查找不便,安全隐患大:没有统一的存储平台,企业大量

    目前大多数互联网软件企业在文件管理方面并没有互联网化,没有文件管理概念或采用落后的文件管理系统。由于互联网软件的行业特性,人才流动频繁,产品迭代计划、产品设计稿源文件、技术知识等核心数据散落在员工电脑或者硬盘里,研发人员的离职,硬盘的损坏,无形之中就会造成企业重要数字资产流失,影响企业的持续高速发展。Yotta企业云盘帮助互联网软件企业实现数据安全管控和知识积累,提高信息共享和数据流转效率,让跨部门/跨区域的协作更加简单高效。
    在这里插入图片描述

    文件管理的行业困扰
    1、存储查找不便,安全隐患大:没有统一的存储平台,企业大量重要文件(产品设计稿源文件、产品需求、技术知识、市场活动、培训材料等)散落在员工电脑上或者移动硬盘,一旦设备损坏或丢失,员工离职,无形之中就会造成企业重要数字资产流失。同时,不能集中管理企业文件,也导致资料查找繁琐。
    2、信息同步滞后、工作效率低:原有的办公模式下,部门间存在信息孤岛,彼此共享信息不及时,沟通成本高。除了内部的信息共享外,定制需求的前期跟客户的沟通确认反馈往往也缺乏顺畅的信息共享机制。工作过程中存在大量的文件协作,信息传递普遍采用社交软件的方式来共享,容易导致文件不能实时获取,信息错漏等问题。
    3、版本混乱、协作能力不足:互联网软件行业的项目往往多线并行甚至交叉进行,项目协作中的设计文档、产品文档、技术文档、需求文档、产品设计稿等需要多部门协同完成和及时同步,通过社交软件、邮箱等传统方式频繁传送无法做到及时同步最新信息,而且容易造成版本混乱,协同办公效率低。
    在这里插入图片描述

    Yotta企业云盘解决方案
    1、文件集中管理与知识沉淀:平台实现企业文件的集中存储和备份,按照企业组织架构建立文件管理框架,把重要文件备份到对应的文件夹里并给相关人员设置对应的权限,实现企业文件集中管理和知识沉淀,使数据价值最大化,以便企业更好地应对大数据时代的挑战。云端不存储明文密钥,攻破数据库也无效,杜绝因平台原因造成的用户数据丢失。
    2、打通各方信息共享渠道:建立共享文件夹、文件一键分享等功能建立快速信息共享方式。公司最新动作实时同步给各相关部门,确保团队信息高度一致。全国各地人员也可以随时获取最新产品信息和数据分享,与此同时灵活的多层级权限设置可以保证共享文件的安全性。
    3、项目高效协作:支持文档、图片、音频、视频等的在线预览查看;无需下载文档,即可在线完成文件修改及编辑与同事、客户高效协同完成工作。

     社会的千遍万化,企业也要顺应时代的发展,快速跟上时代的脚步,提高企业效率,保障企业数据安全。
    
    展开全文
  • 在上篇设计篇中,我们首先从两个维度介绍实时数据平台:从现代数仓架构角度看待实时数据平台,从典型数据处理角度看待实时数据处理;接着我们会探讨实时数据平台整体设计架构、对具体问题的考量以及解决思路。在下篇...
  • 中华石杉场景本项目是基于怎样的一个技术架构,以及大致的数据流转? 好的,先了解一下项目开发流程。Snail认为站在开发者的角度,一个正规的完整的大数据项目(普通J2EE项目也类似)流程大致分为三个阶段:1、架构...
  • MVC(Model View Controller 模型-视图-控制器)是一种典型的软件设计思想,用于应用程序的分层开发。 Model(模型)模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑,在数据变化时更新控制器。 View...
  • 数据驱动开发

    2019-10-06 13:52:00
    留个记号, 从这段时间的设计、开发、测试,...系统设计,根据业务流程中数据的流转进行系统数据流转设计,数据采集-数据验证-数据处理-数据存储-数据提取-数据展示  根据业务系统数据流转,进行设计数据在每个...
  • 详细的信用流转原型图。 内容包括:工作台、企业签约认证、额度管理、客户管理、银单管理(开单、拆单、兑付、融资)、数据汇总等
  • 需求:对邮件通知表,短信表,rtx通知表等通知模块的中间流转表,定期删除创建时间超过指定日期的数据。释放磁盘空间。程序设计-------------------------------------------------------------------------------...
  • 审核状态与数据设计

    千次阅读 2019-03-05 22:41:25
    需求: 在日常开发过程中,经常会遇到这样的需求,需要保存草稿或者改变数据以后需要审核,这个时候就...先说说我这两天的总结,存一条数据,是可以解决上面的问题,但是适合单表操作,设计如下: 字段中添加一个...
  • 背景 接入Kafka实时数据经过数据处理写入HBase,后续会应用于类似变量系统以及...使用的是Max Well数据源,将业务数据接入Kafka,Flink-Source接入Kafka,中间经过数据流转将数据存储到HBase作实时表; 实现 说明
  • 一、“为什么要设计数据分层?” ...作为一名数据的规划者,我们肯定希望自己的数据能够有秩序地流转数据的整个生命周期能够清晰明确被设计者和使用者感知到。直观来讲就是如下的左图这般层次...
  • 作为一名数据的规划者,我们肯定希望自己的数据能够有秩序地流转数据的整个生命周期能够清晰明确被设计者和使用者感知到。直观来讲就是如下的左图这般层次清晰、依赖关系直观。 但是,大多数情况下,我们完成的...
  • 随着业务的发展,可以预期到平台的相关子系统,会出现大量依赖外部系统的API服务以及内部系统之间数据流转的情况。如何高效维护这些内部和外部的API,低成本接入外部的服务成了一个棘手的问题 问题发现 平台内子...
  • 1. 业务数据:业务流程中产生的交易、状态流转、用户等相关的数据,通常存储在 DB 中, 包括 rdbms、nosql等,这部分数据是业务相关的,具体哪些数据需要保留一般由业务侧设计,不需要过度关注,按实际需要采集即可...
  • 一个好的数据结构设计或者说数据库设计,不仅能应对复杂的业务变化,更可以...1. 数据库设计第一原则,领域设计 + 恒等式设计 + 数据流转设计 注:这三个思想后面会单独写篇文章来讲,非常非常重要的指导思想 2...
  • 数据库设计原则(金融行业)

    千次阅读 2018-07-19 11:09:18
    一个好的数据结构设计或者说数据库设计,不仅能应对复杂的业务变化,更可以应对未来海量的数据扩容,同时数据结构逻辑... 数据库设计第一原则,领域设计 + 恒等式设计 + 数据流转设计  注:这三个思想后面会单独写...
  •  百度的解释:框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。其实就是某种应用的半成品,就是一组组件,供你...
  • 电力数据可视化大屏设计

    千次阅读 2019-07-30 14:10:44
    案例一:易数MAX—智慧决策供应链总控平台 1.项目介绍 项目通过制作全过程可视化界看板,跟踪物资数据。智慧决策中心管理人员可根据指标监控数据,...☑ 跟踪各节点的物资流转情况,对异常情况触发相关预警推送。...
  • 第三方时历载荷数据文件转换为SACS格式几周之前,一个同事问我能不能帮她编写一个程序,来解决项目中的一个实际问题。...这位同事正在使用SACS进行海上风电基础设计分析的工作,需要将厂商提供的风机时历载荷数据...
  • 企业信息化管理是指对企业信息化实施过程...建立基于区块链的企业数据溯源平台,就是通过第三方系统实现对不同业务系统数据流转的管控。针对企业信息化管理中的信息安全问题,提出一种基于区块链的企业数据溯源系统。
  • 原文:https://www.cnblogs.com/xdecode/p/9321848.html转载自公众号【java进阶架构师】最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想用动画来绘制数据流转过程.主要基于jdk8, 可能会有些...
  • 产品原型设计工具

    2014-10-26 11:51:08
      2. iRise,支持流程图和示意图,流程图非常灵活,直接跳转...3. Prototype Composer,功能非常齐全(建立项目、多层次的流程设计、界面设计、数据流转设计等等)免费使用,但使用复杂度高,支持中文。  不支持HTM
  • 最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想用动画来绘制数据流转过程. 主要基于jdk8, 可能会有些特性与jdk7之前不相同, 例如LinkedList Link...
  • 产品设计第一阶段,不考虑数据流转,使得产品流程更亲近用户。 流程既定之后,用数据流代替业务流,考虑主要数据的获取和传递,对原有流程进行微调,可降低研发复杂度。 对不对? 2016.11.24 ...
  • 最近在整理数据结构方面的知识, 系统化看了下Java中常用数据结构, 突发奇想用动画来绘制数据流转过程.主要基于jdk8, 可能会有些特性与jdk7之前不相同, 例如LinkedList LinkedHashMap中的双向列表不再是回环的....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 586
精华内容 234
关键字:

数据流转设计