先生_吕
先生_吕

Strom自行整合kafka

前言

最近由于业务线上环境kafka版本有变，导致与其配套的storm已经redis版本都要随之更新。本来想着将kafka的线上版本改回之前版本，这样所有的东西都不用随之变动，不幸的是老大告知线上kafka版本不能变，所以只能去找对应的storm和redis版本了，（注：线上kafka为2.11.0.11.0），在更新storm时发现还没有与之对应的storm-kafka匹配版本，这就意味着不能用storm提供的storm与kafka的整合包了，所以只能自行手写整合。

任务

本次要完成的任务与之前相同，还是走一套完整的storm分析（kafka-storm-kafka-redis），用一个kafka的生产者模拟数据源发给storm，这里要提说的是storm用最传统的开发方式（topology-spout-bolt）

topology：拓扑（bolt的执行逻辑）
spout：storm的数据源，这里接收kafka的数据
bolt：计算任务组件，可以有一个或者多个

环境

kafka2.11.0.11.0
zookeeper3.4.5.0
storm1.0.1
redis3.2.11.0

数据流向

（1）：kafkaProducer生产者发送数据到test主题
（2）：storm从test主题获取数据（spout组件获取）
（3）：spout组件发送给AllDataBolt进行数据处理
（4）：AllDataBolt在execute（）方法中进行业务处理并将所处理的数据下发给kafka各个数据主题
（5）：kafka各个数据主题对应的消费者进行数据消费，并将消费后的数据存储至redis

代码实现

1： 假数据格式

假数据是一条字符串，每条字符串有25个字段，字段与字段之间用空格相隔，每一个字段代表一个特定属性，以下是部分假数据

16 608 0 10010018 17 10 18 19 13 37 839 0.000000 0.000000 0.000000 0 0 0 0 0 0 0 0 0 1508325219 138196
16 608 0 10010018 17 10 18 19 13 38 89 0.000000 0.000000 0.000000 0 0 0 0 0 0 0 0 0 1508325219 388327
16 608 0 10010018 17 10 18 19 13 38 339 0.000000 0.000000 0.000000 0 0 0 0 0 0 0 0 0 1508325219 638286
16 608 0 10010018 17 10 18 19 13 38 589 0.000000 0.000000 0.000000 0 0 0 0 0 0 0 0 0 1508325219 888342
16 608 0 10010018 17 10 18 19 13 38 839 0.000000 0.000000 0.000000 0 0 0 0 0 0 0 0 0 1508325220 138420
16 608 0 10010018 17 10 18 19 13 39 89 0.000000 0.000000 0.000000 0 0 0 0 0 0 0 0 0 1508325220 388487
16 608 0 10010018 17 10 18 19 13 39 339 0.000000 0.000000 0.000000 0 0 0 0 0 0 0 0 0 1508325220 638539

真实环境，这些数据都是球员所带的护腿板上发出的数据，由于我们是local测试，所以需要提前造一些假数据存放在txt中，数据格式与上格式吻合即可

2:maven配置及工具类

    
        org.apache.storm
        storm-core
        1.0.1
    

       
           org.apache.curator
           curator-framework
           2.10.0
           
               
                   log4j
                   log4j
               
               
                   org.jboss.netty
                   netty
               
           
       
       
            commons-collections
            commons-collections
       
    
    
        org.apache.kafka
        kafka_2.11
        
        0.11.0.0
        
            
                org.apache.zookeeper
                zookeeper
            
            
                org.slf4j
                slf4j-log4j12
            
            
                log4j
                log4j
            
            
                
                
            
        
    
    
           redis.clients
           jedis
           2.8.1

HdtasScheme.java

import org.apache.storm.spout.Scheme;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
import org.apache.storm.utils.Utils;

import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.List;

/**
 * Created by Jarno on 2017/5/31.
 */
public class HdtasScheme implements Scheme {
    private static final Charset UTF8_CHARSET;

    //协议类型
    public static final String PROTOCOL_TYPE = "protocol_type";
    //场地ID
    public static final String FIELD_ID = "field_id";
    //主设备ID(终端id)
    public static final String UWB_ID = "uwb_id";
    //护腿板ID
    public static final String SIGN_ID = "sign_id";
    // 年 月 日   时 分 秒  毫秒
    public static final String YEAR = "year";
    public static final String MONTH = "month";
    public static final String DAY = "day";
    public static final String HOUR = "hour";
    public static final String MINUTE = "minute";
    public static final String SECOND = "second";
    public static final String MILLISECOND = "millisecond";
    //定位精度  X Y Z
    public static final String X = "x";
    public static final String Y = "y";
    public static final String Z = "z";
    //加速度 X Y Z
    public static final String A_SPEED_X = "a_speed_x";
    public static final String A_SPEED_Y = "a_speed_y";
    public static final String A_SPEED_Z = "a_speed_z";
    //陀螺仪 X Y Z
    public static final String GYROSCOPE_X = "gyroscope_x";
    public static final String GYROSCOPE_Y = "gyroscope_y";
    public static final String GYROSCOPE_Z = "gyroscope_z";
    //心率
    public static final String HEART_RATE = "heart_rate";
    //电池电量
    public static final String ELECTRIC = "electric";
    //电池充电状态  1：充电  0：放电
    public static final String CHARGING_STATUS = "charging_status";
    //Unix时间戳  秒
    public static final String SERVER_ACCEPT_TIME_S = "server_accept_time_s";
    //Unix时间戳  纳秒
    public static final String SERVER_ACCEPT_TIME_N = "server_accept_time_n";


    @Override
    public List deserialize(ByteBuffer ser) {
        String input = deserializeString(ser);
        String[] strs = input.split(" ");
        if (strs.length != 25) {
            return null;
        }
        return new Values(strs);
    }

    private static String deserializeString(ByteBuffer string) {
        if (string.hasArray()) {
            int base = string.arrayOffset();
            return new String(string.array(), base + string.position(), string.remaining());
        } else {
            return new String(Utils.toByteArray(string), UTF8_CHARSET);
        }
    }

    @Override
    public Fields getOutputFields() {
        return new Fields(PROTOCOL_TYPE, FIELD_ID, UWB_ID, SIGN_ID, YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, MILLISECOND, X, Y, Z, A_SPEED_X, A_SPEED_Y, A_SPEED_Z, GYROSCOPE_X, GYROSCOPE_Y, GYROSCOPE_Z, HEART_RATE, ELECTRIC, CHARGING_STATUS, SERVER_ACCEPT_TIME_S, SERVER_ACCEPT_TIME_N);
    }

    static {
        UTF8_CHARSET = Charset.forName("UTF-8");
    }
}
 
 
2:kafkaProducer模拟数据源读取txt发送数据
 
 
KafkaProducer.java
 
 
import kafka.serializer.StringEncoder;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.clients.producer.Producer;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/**
 * @author lvfang
 * @create 2017-10-15 11:17
 * @desc
 **/
public class KafkaProduce extends Thread {
    private String topic;//主题

    private String src;//数据源

    public KafkaProduce(String topic,String src){
        super();
        this.topic = topic;
        this.src = src;
    }

    //创建生产者
    private Producer createProducer(){
        Properties properties = new Properties();

        //kafka单节点
        properties.put("metadata.broker.list", "192.168.90.240:9092");
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(org.apache.kafka.clients.producer.ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.90.240:9092");

        return new KafkaProducer(properties);
    }

    public void run() {
        BufferedReader br = null;
        try {

            br = new BufferedReader(new FileReader(src));
            // 创建生产者
            Producer producer = createProducer();

            String line = null;
            // 循环发送消息到kafka
            while ((line = br.readLine()) != null) {
                System.out.println("生产数据为："+line);
                producer.send(new ProducerRecord(topic,line + "\n"));

                // 发送消息的时间间隔
                Thread.sleep(1000);//TimeUnit.SECONDS.sleep(333);
            }
        } catch (Exception e) {
        } finally {
            try { if (br != null) br.close(); } catch (IOException e) {}
        }
    }

    public static void main(String[] args) {
        // 使用kafka集群中创建好的主题 test
        new KafkaProduce("htb_position_test","D:/testdata/htb_position_test_data.txt").start();
    }
}

 
 
写完生产之后我们先试试是否可以顺利发送数据
 
 
 
  
 
   
 
    Strom自行整合kafka_第1张图片 
   
 
  
 
  

    2017-10-19_103248.png 
  
 
 
 
 
 
  
 
   
 
    Strom自行整合kafka_第2张图片 
   
 
  
 
  

    2017-10-19_103312.png 
  
 
 
 
 
数据顺利发送，第一步 我们的数据源就成功了
 
 
3：编写storm逻辑
 
 
这里storm扮演的角色主要是计算，它将计算好的数据再次分发送给kafka；在这个过程中，主要有三个组件参与到其中，spout、bolt、topology，spout作为数据源接收kafka对应主题所分发的数据；bolt是数据计算组件，每一个bolt做一次计算，当然，这里我们为了简单，都在一个bolt中处理了；topology主要是storm组件的拼凑逻辑，即决定bolt的执行顺序，类似于工作流中的逻辑图一样。
 
 
3.1：spout数据源，这里数据源spout进行了抽取，我们知道spout的实现由两种方式，这里使用实现IRichSpout
 
 
KafkaSpout.java
 
 
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.ByteArrayDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.storm.Config;
import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.IRichSpout;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.tuple.Fields;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;


public abstract class KafkaSpout implements IRichSpout {
    private static final long serialVersionUID = 3679050534053612196L;

    public static final Logger logger = LoggerFactory.getLogger(KafkaSpout.class);
    private final Properties props;
    private SpoutOutputCollector collector;
    private List topicList;
    private final AtomicInteger spoutPending;
//    private int maxSpoutPending;
    private KafkaConsumer consumer;

    public KafkaSpout(Properties props, List topics) {
        this.props = props;
        initProps();
        this.topicList = topics;
        this.spoutPending = new AtomicInteger();
    }

    private void initProps() {
        this.props.put("key.deserializer", StringDeserializer.class);
        this.props.put("value.deserializer", ByteArrayDeserializer.class);
    }


    public abstract Fields generateFields();

    public abstract List generateTuple(byte[] message);

    @Override
    public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
        this.collector = collector;
//        this.maxSpoutPending = Integer.parseInt(conf.get(Config.TOPOLOGY_MAX_SPOUT_PENDING).toString());
    }

    @Override
    public void close() {

    }

    @Override
    public void activate() {
        consumer = new KafkaConsumer(props);
        consumer.subscribe(topicList);
        final ExecutorService executor = Executors.newFixedThreadPool(topicList.size());
        executor.submit(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    ConsumerRecords records = consumer.poll(100);
                    Iterator> iterator = records.iterator();
                    while (iterator.hasNext()) {
                        if (spoutPending.get() <= 0) {
                            sleep(1000);
                            continue;
                        }
                        ConsumerRecord next = iterator.next();
                        byte[] message = next.value();
                        List tuple = null;
                        try {
                            tuple = generateTuple(message);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        if (tuple == null) {
                            continue;
                        }
//                          logger.info("kafka spout emit tuple:{}", tuple.toString());
                        collector.emit(tuple);
                        spoutPending.decrementAndGet();
                    }
                }
            }
        });
    }

    @Override
    public void deactivate() {
        consumer.close();
    }

    @Override
    public void nextTuple() {
//        if (spoutPending.get() < maxSpoutPending) {
//            spoutPending.incrementAndGet();
//        }
        spoutPending.incrementAndGet();
    }

    @Override
    public void ack(Object msgId) {
    }

    @Override
    public void fail(Object msgId) {

    }

    @Override
    public Map getComponentConfiguration() {
        return null;
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(generateFields());
    }

    private void sleep(long millisecond) {
        try {
            Thread.sleep(millisecond);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
 
上边的KafkaSpout是一个抽象方法，他实现了IRichSpout接口并重写了接收和发送消息的方法，而留有两个抽象方法为实现，一个是Fields generateFields()，他需要开发人员根据业务对不同的数据进行不同的实现，主要是返回数据切分后的列字段，已被bolt处用相应字段接收；另一个是List generateTuple(byte[] message)方法，他是一个真正的消息接收发送方法，他接收到消息对消息进行切分。业务人员要实现自己spout数据源需要基础KafkaSpout， 并重写以上两个方法。
 
 
HdtasSpout.java
 
 
import com.misbio.seer.storm.KafkaSpout;
import com.misbio.seer.storm.hdtas.HdtasScheme;
import org.apache.storm.tuple.Fields;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * @author lvfang
 * @create 2017-10-16 16:40
 * @desc
 **/
public class HdtasSpout extends KafkaSpout {


    public HdtasSpout(Properties props, List topics){
        super(props,topics);
    }

    public List generateTuple(byte[] message){
        System.out.println(new String(message).split(" ")[1]);
        String[] messages = new String(message).split(" ");
        if(messages.length!=25) return null;



        List tuple = new ArrayList();
        tuple.add(messages[0]);
        tuple.add(messages[1]);
        tuple.add(messages[2]);
        tuple.add(messages[3]);
        tuple.add(messages[4]);
        tuple.add(messages[5]);
        tuple.add(messages[6]);
        tuple.add(messages[7]);
        tuple.add(messages[8]);
        tuple.add(messages[9]);
        tuple.add(messages[10]);
        tuple.add(messages[11]);
        tuple.add(messages[12]);
        tuple.add(messages[13]);
        tuple.add(messages[14]);
        tuple.add(messages[15]);
        tuple.add(messages[16]);
        tuple.add(messages[17]);
        tuple.add(messages[18]);
        tuple.add(messages[19]);
        tuple.add(messages[20]);
        tuple.add(messages[21]);
        tuple.add(messages[22]);
        tuple.add(messages[23]);
        tuple.add(messages[24]);

        return tuple;
    }

    public Fields generateFields(){
        return new Fields(
                HdtasScheme.PROTOCOL_TYPE,
                HdtasScheme.FIELD_ID,
                HdtasScheme.UWB_ID,
                HdtasScheme.SIGN_ID,
                HdtasScheme.YEAR,
                HdtasScheme.MONTH,
                HdtasScheme.DAY,
                HdtasScheme.HOUR,
                HdtasScheme.MINUTE,
                HdtasScheme.SECOND,
                HdtasScheme.MILLISECOND,
                HdtasScheme.X,
                HdtasScheme.Y,
                HdtasScheme.Z,
                HdtasScheme.A_SPEED_X,
                HdtasScheme.A_SPEED_Y,
                HdtasScheme.A_SPEED_Z,
                HdtasScheme.GYROSCOPE_X,
                HdtasScheme.GYROSCOPE_Y,
                HdtasScheme.GYROSCOPE_Z,
                HdtasScheme.HEART_RATE,
                HdtasScheme.ELECTRIC,
                HdtasScheme.CHARGING_STATUS,
                HdtasScheme.SERVER_ACCEPT_TIME_S,
                HdtasScheme.SERVER_ACCEPT_TIME_N
        );
    };
}
 
 
3.2Bolt编写，此bolt主要对spout所发送的数据进行接收计算处理，处理之后并下发给对应的主题供kafka再次消费使用，这里同样bolt的实现方式也有两种，我们这里采用继承BaseBasicBolt的实现方式
 
 
HdtasDataAllBolt.java
 
 
import com.misbio.seer.kafka.DefaultProducer;
import com.misbio.seer.storm.hdtas.HdtasScheme;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.BasicOutputCollector;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseBasicBolt;
import org.apache.storm.tuple.Tuple;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author lvfang
 * @create 2017-10-16 17:33
 * @desc
 **/
public class HdtasDataAllBolt extends BaseBasicBolt {
        private final static Logger LOG = LoggerFactory.getLogger(HdtasDataAllBolt.class);
        private String kafkaUri;
        private Producer createProducer;

        public HdtasDataAllBolt(){}

        public HdtasDataAllBolt(String kafkaUri) {
            this.kafkaUri = kafkaUri;
        }

        @Override
        public void prepare(Map stormConf, TopologyContext context) {
            super.prepare(stormConf, context);
            this.createProducer = new DefaultProducer().createProducer(kafkaUri, null);
        }

        long start = System.currentTimeMillis();
        int count = 0;

        @Override
        public void execute(Tuple input, BasicOutputCollector collector) {

            String fieldId = input.getStringByField(HdtasScheme.FIELD_ID);//获取球场id
            String signId = input.getStringByField(HdtasScheme.SIGN_ID);//标签id

            //加速度 X Y Z
            String aSpeedX = input.getStringByField(HdtasScheme.A_SPEED_X);
            String aSpeedY = input.getStringByField(HdtasScheme.A_SPEED_Y);
            String aSpeedZ = input.getStringByField(HdtasScheme.A_SPEED_Z);
            //定位精度  X Y Z
            String x = input.getStringByField(HdtasScheme.X);
            String y = input.getStringByField(HdtasScheme.Y);
            String z = input.getStringByField(HdtasScheme.Z);
            //陀螺仪 X Y Z
            String gyroscopeX = input.getStringByField(HdtasScheme.GYROSCOPE_X);
            String gyroscopeY = input.getStringByField(HdtasScheme.GYROSCOPE_Y);
            String gyroscopeZ = input.getStringByField(HdtasScheme.GYROSCOPE_Z);

            String heartRate = input.getStringByField(HdtasScheme.HEART_RATE);//心率
            String electric = input.getStringByField(HdtasScheme.ELECTRIC);//电池电量

            String charingStatus = input.getStringByField(HdtasScheme.CHARGING_STATUS);//充电状态
            String timeS = input.getStringByField(HdtasScheme.SERVER_ACCEPT_TIME_S);//时间戳 秒
            long time = convertMilTime(input);
            if ("1523".equals(signId)){
                return;
            }

            //x y < 0.01
            double doubleX = Double.valueOf(x).doubleValue();
            double doubleY = Double.valueOf(y).doubleValue();

            if(doubleX<0.01 || doubleY <0.01){
                return;
            }
//            if(x.equals("0.000000") || y.equals("0.000000")){
//                return;
//            }
            System.out.println("X&Y : " + x + " : " + y);
            //三个轴的加速度值 单位g  16384/8 = 2048  16g量程
            double ax = BigDecimal.valueOf(Integer.parseInt(aSpeedX)).divide(BigDecimal.valueOf(2048), 3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            double ay = BigDecimal.valueOf(Integer.parseInt(aSpeedY)).divide(BigDecimal.valueOf(2048), 3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            double az = BigDecimal.valueOf(Integer.parseInt(aSpeedZ)).divide(BigDecimal.valueOf(2048), 3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            //三个轴的陀螺仪值 单位为dps 度每秒  131/8 = 16.375  2000度量程
            double gx = BigDecimal.valueOf(Integer.parseInt(gyroscopeX)).divide(BigDecimal.valueOf(16.375), 3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            double gy = BigDecimal.valueOf(Integer.parseInt(gyroscopeY)).divide(BigDecimal.valueOf(16.375), 3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            double gz = BigDecimal.valueOf(Integer.parseInt(gyroscopeZ)).divide(BigDecimal.valueOf(16.375), 3, BigDecimal.ROUND_HALF_DOWN).doubleValue();

            //加速度矢量
            double r = BigDecimal.valueOf(Math.sqrt(ax * ax + ay * ay + az * az)).setScale(3,BigDecimal.ROUND_HALF_DOWN).doubleValue();
            if (0d == r) {
                return;
            }
            //结果放入kafka中(hdtas_all_ori_a_speed)
            final String result = signId + "," + ax + "," + ay + "," + az + "," + r + "," + time;

            createProducer.send(new ProducerRecord("hdtas_all_ori_a_speed",fieldId,result));
            long end = System.currentTimeMillis();

            if (end - start <= 1000) count++; else { start = end; count = 0;}
            //认为异常数据 不予处理
            if (ax == 0 && ay == 0 && az == 0) return;

            //计算步数
            Integer step = computeStep(fieldId, signId, r, time);
            //计算三个轴的角度变化
            computeAngle(ax, ay, az);
            //计算瞬时速度
            computeInstantSpeed(time, ax, ay, az);
            //计算位置
            computePosition(signId , fieldId , x , y , z , time);
            //计算速度(有问题)
            computeSpeed(signId , fieldId , x , y , z , time);
            //其他数据（陀螺仪，加速度，心率，电量等等）
            computeOther(signId , fieldId , electric , heartRate , time , ax , ay , az , gx , gy , gz , r , step);
            //计算灵敏度
            computeAgile(signId , fieldId , gx , gy , gz , time);
            //计算电量
            computeBattery(signId , fieldId , electric , time);
            //计算距离s
            computeDistance(signId , fieldId , x , y , z , time);
            //计算心率
            computeHeartrate(signId , fieldId , heartRate , time);
        }

        Map lastRMap = new HashMap();//加速度矢量
        Map stepMap = new HashMap();
        //    Map currentPeakTimeMap = new HashMap();
        Map lastPeakTimeMap = new HashMap();

        /**
         * 计算步数
         * @param fieldId
         * @param signId
         * @param r
         * @param time
         */
        private Integer computeStep(String fieldId, String signId, double r, long time) {
            Double lastR = lastRMap.get(signId);
            if (lastR == null) {
                lastRMap.put(signId, r);
            } else {
                boolean isPeak = detectPeak(signId, lastR, r);
                if (isPeak){
                    Long lastPeakTime = lastPeakTimeMap.get(signId);
                    if (lastPeakTime == null) {
                        lastPeakTime = 0L;
                    }
                    Double peak = lastPeakMap.get(signId);
                    Double valley = lastValleyMap.get(signId);
                    if (peak == null || valley == null){
                        return 0;
                    }
                    //得到阙值
                    double threshold = peak - valley;
                    //System.out.println("阈值：" + threshold);
                    Integer step = stepMap.get(signId);
                    if (step == null) {
                        step = 0;
                        stepMap.put(signId, 0);
                    }
                    Double bt = baseThresholdMap.get(signId);
                    if (bt == null){
                        baseThresholdMap.put(signId, baseThreshold);
                        bt = baseThreshold;
                    }
                    System.out.println("baseThreshold：" + bt);
                    if (time - lastPeakTime >= 250 && (threshold >= bt)){
                        lastPeakTimeMap.put(signId, time);
                        stepMap.put(signId, step + 1);
                    }
                    if (time - lastPeakTime >= 250 && (threshold >= 1.3d)){
                        lastPeakTimeMap.put(signId, time);
                        double aveThreshold = computeThreshold(signId, threshold);
                        System.out.println("aveThreshold：" + aveThreshold);
                        baseThresholdMap.put(signId, aveThreshold);
                    }

                    //结果放入kafka中
                    final String result = signId + "," + threshold;
                    final StringBuilder sb = new StringBuilder(result);
                    sb.append(",").append(stepMap.get(signId));

                    return stepMap.get(signId);

//                createProducer.send(new ProducerRecord("hdtas_all_step",fieldId,sb.toString()));
                }
                lastRMap.put(signId, r);
            }
            return 0;

        }
        private double stepAvgNum = 4;
        private double computeThreshold(String signId, double threshold) {
            double temp = baseThreshold;
            List thresholdList = aveThresholdMap.get(signId);
            if (thresholdList == null){
                thresholdList = new ArrayList();
            }
            //System.out.println("size:" +thresholdList.size());
            if (thresholdList.size() < stepAvgNum) {
                thresholdList.add(threshold);
                aveThresholdMap.put(signId,thresholdList);
            }else{
                temp = computeAvgThreshold(thresholdList);
                thresholdList.add(threshold);
                thresholdList.remove(0);
                aveThresholdMap.put(signId,thresholdList);
            }

            return temp;
        }


        private double computeAvgThreshold(List thresholdList) {
            int size = thresholdList.size();
            double all = 0;
            for (double d : thresholdList){
                all += d;
            }
            double ave = new BigDecimal(all).divide(new BigDecimal(size), 3).setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            if (ave >= 8) {
                ave = 4.3d;
            }
            else if(ave >= 7 && ave < 8){
                ave = 3.3d;
            }
            else if(ave >= 4 && ave < 7){
                ave = 2.3d;
            }
            else if(ave >= 3 && ave <4){
                ave = 2.0d;
            }
            else {
                ave = 1.3d;
            }
            return ave;
        }

        //记录当前上升状态
        private Map upMap = new HashMap();
        //记录上一次上升状态
        private Map lastUpMap = new HashMap();
        //记录上升趋势次数
        private Map upCountMap = new HashMap();
        //记录上一次上升趋势次数
        private Map lastUpCountMap = new HashMap();
        //记录波峰的值
        private Map lastPeakMap = new HashMap();
        //记录波谷的值
        private Map lastValleyMap = new HashMap();
        private Map> aveThresholdMap = new HashMap>();
        private Map thresholdMap = new HashMap();

        private double baseThreshold = 2.0d;
        private Map baseThresholdMap = new HashMap();

        /**
         * 检测波峰
         *
         * @param signId
         * @param lastR
         * @param newR   1.下降趋势
         *               2.上一个点为上升趋势
         *               3.持续上升次数大于等于2
         *               4.波峰值判断（>=4走路 >=6慢跑 >=8快跑 >=9跳跃）
         * @return
         */
        private boolean detectPeak(String signId, Double lastR, double newR) {
            Boolean isUp = upMap.get(signId);
            if (isUp == null) {
                lastUpMap.put(signId, false);
            }else{
                lastUpMap.put(signId, isUp);
            }
            Integer count = upCountMap.get(signId);
            //上升趋势
            // && (newR - lastR) >= baseThreshold
            if (newR >= lastR) {
                upMap.put(signId, true);
                upCountMap.put(signId, count == null ? 1 : count + 1);
            } else {
                lastUpCountMap.put(signId, count == null ? 0 : count);
                upCountMap.put(signId, 0);
                upMap.put(signId, false);

            }
            boolean lastUp = lastUpMap.get(signId);
            boolean currentUp = upMap.get(signId);
            Integer lastUpCount = lastUpCountMap.get(signId);
            if (lastUpCount == null) {lastUpCount = 0;}
            double baseR = 20 / 9.8;
            if( !currentUp && lastUp && (lastUpCount >= 2 || lastR >= baseR)){
                lastPeakMap.put(signId, lastR);
                return true;
            }
            else if (currentUp && !lastUp){
                lastValleyMap.put(signId, lastR);
                return false;
            }else {
                return false;
            }
        }

        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {

        }

        /**
         * 计算三个轴的角度变化
         * @param ax
         * @param ay
         * @param az
         */
        private void computeAngle(double ax, double ay, double az) {
            double r = Math.sqrt(ax * ax + ay * ay + az * az);
            double arx = (180 / Math.PI) * Math.acos(ax / r);
            double ary = (180 / Math.PI) * Math.acos(ay / r);
            double arz = (180 / Math.PI) * Math.acos(az / r);


//        double myarx = -1;
//        double myary = -1;
////        System.out.println("----------------转换后角度");
//        if (arz > 0 && arz <= 90) {
//            myarx = arx - 90;
//            myary = ary - 90;
//        }
//        if (arz > 90) {
//            if (arx >= 0 && arx <= 90) {
//                myarx = -90 - arx;
//            }
//            if (arx > 90) {
//                myarx = 180 - arx + 90;
//            }
//            if (ary >= 0 && ary <= 90) {
//                myary = - 90 - ary;
//            }
//            if (ary > 90) {
////                System.out.println("Y轴:" + (180 - ary + 90));
//                myary = 180 - ary + 90;
//            }
//        }
//
        }


        private long lastMillisecond = -1;
        private long lastTime = 0;
        private double lastAx = -1;
        private double lastAy = -1;
        private double lastAz = -1;
        private double lastV = 0;

        /**
         * 计算瞬时速度
         * @param time
         * @param ax
         * @param ay
         * @param az
         */
        private void computeInstantSpeed(long time, double ax, double ay, double az) {
            if (lastMillisecond != -1 && lastAx != -1 && lastAy != -1 && lastAz != -1) {
                double ds = (time - lastMillisecond) / 1000d;
                if (ds <= 0) {
                    lastMillisecond = time;
                    return;
                }

                double vx = (ax - lastAx) / 2 * ds;
                double vy = (ay - lastAy) / 2 * ds;
                double vz = (az - lastAz) / 2 * ds;

//            double vx_pow = Math.pow(vx , 2);
//            double vy_pow = Math.pow(vy, 2);
//            double vz_pow = Math.pow(vz, 2);

//            double v = Math.sqrt(vx_pow + vy_pow + vz_pow);
                double v = vx + vy + vz;
                lastV = v;
//            if(v > 8 ){
//            if (v < 0){
//                v = 0.000;
//            }
                v = new BigDecimal(v).setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
//            System.out.println("瞬时速度为:" + v);

            }
            lastMillisecond = time;
            lastAx = ax;
            lastAy = ay;
            lastAz = az;
        }

        private long convertMilTime(Tuple input) {
            String year = input.getStringByField(HdtasScheme.YEAR);
            String month = input.getStringByField(HdtasScheme.MONTH);
            String day = input.getStringByField(HdtasScheme.DAY);
            String hour = input.getStringByField(HdtasScheme.HOUR);
            String minute = input.getStringByField(HdtasScheme.MINUTE);
            String second = input.getStringByField(HdtasScheme.SECOND);

            String millisecond = input.getStringByField(HdtasScheme.MILLISECOND);
            SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd HH:mm:ss:SSS");
            String time = year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second + ":" + millisecond;
//            System.out.println(time);
            try {
                Date date = sdf.parse(time);
//                System.out.println(date.getTime());
                //线上时间
                return date.getTime();
                //测试时间
//                return System.currentTimeMillis();
            } catch (ParseException e) {
                e.printStackTrace();
                LOG.error("convertMilTime date format error, error info is {}", e.getMessage());
                return System.currentTimeMillis();
            }
        }

        /**
         * 计算灵敏度
         * @param userId
         * @param fieldId
         * @param x
         * @param y
         * @param z
         * @param time
         */
        public void computeAgile(String userId , String fieldId , double x , double y , double z , Long time){
            final String result = userId + "," + fieldId + "," + x + "," + y + "," + z + "," + time;

            createProducer.send(new ProducerRecord("hdtas_agile_bolt",fieldId,result));
        }

        /**
         * 计算电量
         * @param userId
         * @param electric
         * @param time
         */
        public void computeBattery(String userId , String fieldId , String electric , Long time){
            final String result = userId + "," + electric + "," +time;

            createProducer.send(new ProducerRecord("hdtas_battery_bolt",fieldId,result));
        }


        private final Map oldXdis = new HashMap();
        private final Map oldYdis = new HashMap();
        private final Map oldTimedis = new  HashMap();
        private final Map oldTimeDistance = new  HashMap();
        private Map distancePositionMap = new HashMap();
        /**
         * 计算距离
         * @param userId
         * @param fieldId
         * @param x
         * @param y
         * @param z
         * @param time
         */
        public void computeDistance(String userId , String fieldId , String x , String y , String z , Long time){
            double dx = Double.parseDouble(x);
            double dy = Double.parseDouble(y);
            double dz = Double.parseDouble(z);

            Long oldLongTime = oldTimeDistance.get(userId);
            Position p = distancePositionMap.get(userId);

            if(p == null){
                oldTimeDistance.put(userId, time);
                distancePositionMap.put(userId,new Position(dx,dy,dz));
                return;
            }
            if(oldLongTime == null){
                oldTimeDistance.put(userId,time);
                return;
            }

            double absX = Math.abs((dz-p.getX()));
            double absY = Math.abs((dy-p.getY()));
            double absZ = Math.abs((dz-p.getZ()));


            double dis = new BigDecimal(Math.sqrt(absX*absX + absY*absY)).setScale(5,BigDecimal.ROUND_HALF_UP).doubleValue();
            long diff = Math.abs(time - oldLongTime);

            if (diff >= 1000){
                double speed =  new BigDecimal(dis).divide(new BigDecimal(diff).divide(new BigDecimal(1000),3,BigDecimal.ROUND_HALF_EVEN),5,BigDecimal.ROUND_HALF_EVEN).doubleValue();

                //存储
                Position p1 = new Position(dx,dy,dz);
                distancePositionMap.put(userId, p1);
                oldTimeDistance.put(userId, time);

                String result = userId + "," + fieldId + "," +time + "," + diff + "," + dis + "," + speed;

                createProducer.send(new ProducerRecord("hdtas_distance_bolt",fieldId,result));
            }
        }

        /**
         * 计算心率
         * @param userId
         * @param fieldId
         * @param heartRate
         * @param time
         */
        public void computeHeartrate(String userId , String fieldId , String heartRate , Long time){
            final String result = userId + "," + fieldId + "," +time + "," + heartRate;

            createProducer.send(new ProducerRecord("hdtas_heartrate_bolt",fieldId,result));
        }

        /**
         * 计算坐标
         * @param userId
         * @param fieldId
         * @param x
         * @param y
         * @param z
         * @param time
         */
        public void computePosition(String userId , String fieldId , String x , String y , String z , Long time){
            final String result = userId + "," + fieldId + "," +time + "," + x + "," + y;
            System.out.println("位置数据：" + result);
            createProducer.send(new ProducerRecord("hdtas_position_bolt",fieldId,result));
        }

        private final Map oldTimespeed = new  HashMap();
        private Map speedPositionMap = new HashMap();

        /**
         * 计算速度
         * @param userId
         * @param fieldId
         * @param x
         * @param y
         * @param z
         * @param time
         */
        public void computeSpeed(String userId , String fieldId , String x , String y , String z , long time){
            double sx = Double.parseDouble(x);
            double sy = Double.parseDouble(y);
            double sz = Double.parseDouble(z);

            Long oldLongTime = oldTimespeed.get(userId);
            Position p = speedPositionMap.get(userId);
            if(p == null){
                oldTimespeed.put(userId, time);
                speedPositionMap.put(userId,new Position(sx,sy,sz));
                return;
            }
            if (oldLongTime == null){
                oldTimespeed.put(userId, time);
                return;
            }


            double absX = Math.abs((sz-p.getX()));
            double absY = Math.abs((sy-p.getY()));
            double absZ = Math.abs((sz-p.getZ()));

            double dis = new BigDecimal(Math.sqrt(absX*absX + absY*absY)).setScale(5,BigDecimal.ROUND_HALF_UP).doubleValue();
            long diff = Math.abs(time - oldLongTime);
            System.out.println("diff : ++++++++++++" + absX+","+absY);
            System.out.println("dis : ++++++++++++" + dis);
//            double speed = dis/(diff/1000);
            if (diff >= 1000){
                double speed =  new BigDecimal(dis).divide(new BigDecimal(diff).divide(new BigDecimal(1000),3,BigDecimal.ROUND_HALF_EVEN),5,BigDecimal.ROUND_HALF_EVEN).doubleValue();
                System.out.println("speed : ++++++++++++" + dis);

                //存储
                Position p1 = new Position(sx,sy,sz);
                speedPositionMap.put(userId, p1);
                oldTimespeed.put(userId, time);

                String result = userId + "," + fieldId + "," +time + "," + diff + "," + dis + "," + speed;
                System.out.println("速度数据：" + result);
                createProducer.send(new ProducerRecord("hdtas_speed_bolt",fieldId,result));
            }

        }

        /**
         * 其他参数
         * @param userId 用户id
         * @param fieldId 球场id
         * @param battery 电量
         * @param heartRate 心率
         * @param time 当前毫秒值
         * @param ax
         * @param ay
         * @param az
         * @param gx
         * @param gy
         * @param gz
         * @param r
         */
        public void computeOther(String userId , String fieldId , String battery , String heartRate , long time , double ax , double ay , double az , double gx , double gy , double gz , double r , Integer step){

            String result = userId + "," + fieldId + "," + battery+ "," + heartRate + ","
                    + ax + "," + ay + "," + az + ","
                    + gx + "," + gy + "," + gz + ","
                    + r + "," + step + "," + time;
            System.out.println("其他数据： " + result);
            createProducer.send(new ProducerRecord("hdtas_other_bolt",fieldId,result));
        }
    }


 
 
3.3topology编写，这里topology是一个bolt的逻辑视图，决定bolt的流向
 
 
import com.misbio.seer.storm.hdtas.bolt.HdtasDataAllBolt;
import com.misbio.seer.storm.hdtas.spout.HdtasSpout;
import com.misbio.seer.utils.ResourceUtils;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.BytesDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.topology.TopologyBuilder;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * @author lvfang
 * @create 2017-10-16 16:31
 * @desc
 **/
public class TopologyHdtas {

    // 主题与zk端口(local)
    public static final Integer ZK_PORT = Integer.parseInt(ResourceUtils.getProperty("zookeeper.port"));
    public static final String ZK_HOST = ResourceUtils.getProperty("zookeeper.host");
    public static final String ZKINFO = ResourceUtils.getProperty("zookeeper.connect.kafka");

    public static final String KAFKA_URL = ResourceUtils.getProperty("kafka.broker");
    public static final String ZKROOT = "/hdtas";
    public static final String SPOUTID = "hdtas";

    private static final String HDTAS_SPOUT = "hdtasSpout";
    private static final String HDTAS_ALL_BOLT = "hdtas_all_bolt";

    public static void main(String[] args) throws Exception{
        Config cfg = new Config();
        cfg.setNumWorkers(2);
        cfg.setDebug(true);

        Properties properties = new Properties();
        //kafka 设置
        properties.put("group.id", "group1");
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, KAFKA_URL);
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, BytesDeserializer.class);

        List topics = new ArrayList();
        topics.add("htb_position_test");

        //组件执行顺序逻辑
        TopologyBuilder builder = new TopologyBuilder();
        //先创造spout数据源PWSpout
        builder.setSpout("spout", new HdtasSpout(properties,topics));

        //在创建bolt组件PrintBolt，并接受分组id为“spout”的数据
        builder.setBolt("print-bolt", new HdtasDataAllBolt(KAFKA_URL)).shuffleGrouping("spout");

        //1 本地模式
        LocalCluster cluster = new LocalCluster();
        cluster.submitTopology("top1", cfg, builder.createTopology());//提交分析
        Thread.sleep(10000000);//10000毫秒后停止实时计算
        cluster.killTopology("top1");
        cluster.shutdown();

        //2集群模式
//        StormSubmitter.submitTopology("top1", cfg,builder.createTopology());
    }
}

 
 
在编写完topology之后，我们就可以启动程序看看能否跑通
 
 
 
  
 
   
 
    Strom自行整合kafka_第3张图片 
   
 
  
 
  

    2017-10-19_112349.png 
  
 
 
 
 
 
  
 
   
 
    Strom自行整合kafka_第4张图片 
   
 
  
 
  

    2017-10-19_112448.png 
  
 
 
 
 
我们可以看到，数据经过处理后已经发送到对应的主题，剩下的工作就是编写主题消费后持久化到redis
 
 
3.4KafkaCusumer主要对storm计算后的数据进行消费，storm计算后将数据根据类型分别下发到了位置主题、距离主题、速度主题、心率主题、电量主题、陀螺仪主题等等，这里我们只编写一个主题的消费，其他等同
 
 
KafkaCusumer.java
 
 
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.serialization.BytesDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.util.Arrays;
import java.util.Properties;


/**
 * @author lvfang
 * @create 2017-10-15 11:17
 * @desc
 **/
public class KafkaCusumer extends Thread  {
    private String topic;//主题

    public final String SRC = "D:/testdata/testData.txt";

    public KafkaCusumer(String topic){
        super();
        this.topic = topic;
    }

    //创建消费者
    private Consumer createConsumer(){
        Properties properties = new Properties();
        //必须要使用别的组名称， 如果生产者和消费者都在同一组，则不能访问同一组内的topic数据
        properties.put("group.id", "group1");
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.90.240:9092");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, BytesDeserializer.class);

        return new KafkaConsumer(properties);

    }

    @Override
    public void run() {
        //创建消费者
        Consumer consumer = createConsumer();

        consumer.subscribe(Arrays.asList(topic));

        while (true) {

            ConsumerRecords records = consumer.poll(100);

            for (ConsumerRecord record : records) {

                System.out.println("消费到的数据为："+record.value());
                //System.out.printf("接收到: ", record.offset(), record.key(), record.value());
            }
        }
    }

    public static void main(String[] args) {
        new KafkaCusumer("htb_position_test").start();
    }
}

 
 
编写完后我们可以启动消费，看看是否可以消费到
 
 
 
  
 
   
 
    Strom自行整合kafka_第5张图片 
   
 
  
 
  

    2017-10-19_113515.png 
  
 
 
 
 
这里消费是将数据直接打印出来了，至于持久化，我们在打印之后存储即可，这里就不在写了，完毕！！！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Strom自行整合kafka)

        

            

                
    
                    
  • Kafka 消息丢失如何处理？
                        架构文摘JGWZ
学习
                        
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
    
                    
    • 
                    
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片
                        诚芯微科技
社交电子
                        
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
    
                    
    • 
                    
  • 摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发
                        诚芯微科技
社交电子
                        
    长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
    
                    
    • 
                    
  • 【六】阿伟开始搭建Kafka学习环境
                        能源恒观
中间件学习kafkaspring
                        
    阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • Kafka是如何保证数据的安全性、可靠性和分区的
                        喜欢猪猪
kafka分布式
                        
    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
    
                    
    • 
                    
  • 承担即成长
                        吉林付巍巍

                        
    《苏霍姆林斯基教育学》课程，几天前召开了义工培训会，我听了回放后主动联系郑老师要求加入义工团队。虽然这样每周要付出至少一天的时间进行打卡阅读和点评，但这样可以强迫规划好每日的作息时间，完成专业阅读方面的学习，这种重要的事情是必须要融入日常的生活中的，这一工作的申请也督促我合理安排自己的时间，把碎片化的时间整合好，无形中提高了每日利用时间的效率。上学期跟随着教师阅读地图课程组进行点评，发现了许多优秀
    
                    
    • 
                    
  • 【2023年】云计算金砖牛刀小试6
                        geekgold
云计算服务器网络kubernetes容器
                        
    第一套【任务1】私有云服务搭建[10分]【题目1】基础环境配置[0.5分]使用提供的用户名密码，登录提供的OpenStack私有云平台，在当前租户下，使用CentOS7.9镜像，创建两台云主机，云主机类型使用4vCPU/12G/100G_50G类型。当前租户下默认存在一张网卡，自行创建第二张网卡并连接至controller和compute节点（第二张网卡的网段为10.10.X.0/24，X为工位号
    
                    
    • 
                    
  • LeetCode github集合，附CMU大神整理笔记
                        Wesley@
LeetCodegithub
                        
    GithubLeetCode集合本人所有做过的题目都写在一个java项目中，同步到github中了，算是见证自己的进步。github目前同步的题目是2020-09-17日之后写的题。之前写过的题会陆续跟新到github中。目前大概400个题目Github项目链接：https://github.com/sunliancheng/leetcode_github附上一份优秀的教材整合：这是卡内基梅隆(C
    
                    
    • 
                    
  • 郭生白中药方论之二(破除温凉寒热的框框)
                        本能学堂a昨年

                        
    离病说药茫茫然，对症下药不着边。顺势利导一乘法，排异调节渡法船。无限整合非模糊，模糊病区得清楚。共性之外求个性，亲和不生抗药性。温凉寒热巧方便，君臣佐使筏喻焉。药包大小折中看，毒性有无一念间。导读破除温凉寒热的框框寒热温凉是基于中药共性的传统分类药无寒热人有寒热药无寒热病有寒热抛弃温凉不并用的错误观念寒热温凉是基于中药共性的传统分类寒热温凉是个共性，是说的共性。这个共性，知道什么叫共性吗？所有的药
    
                    
    • 
                    
  • [数据集][目标检测]汽车头部尾部检测数据集VOC+YOLO格式5319张3类别
                        FL1623863129
数据集目标检测汽车YOLO
                        
    数据集制作单位：未来自主研究中心(FIRC)版权单位：未来自主研究中心(FIRC)版权声明：数据集仅仅供个人使用，不得在未授权情况下挂淘宝、咸鱼等交易网站公开售卖,由此引发的法律责任需自行承担数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：5319标注数量(xml文件
    
                    
    • 
                    
  • 自由职业者做什么赚钱？省钱快报能月入三千吗？
                        高省APP珊珊

                        
    说起省钱快报，很多人都觉得很耳熟，省钱快报是一个社交电商平台，省钱快报是一个给大家提供优惠券一级购物返佣的优惠平台,整合了京东淘宝拼多多等等各大电商平台的优惠券和佣金，用户领券购买更优惠！所有的售后服务也都还和你之前的平台买东西一样，副业赚钱，可以用省钱快报来增加收入。至于我为何转到高省APP呢？当然是高省佣金更高，模式更好。高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金
    
                    
    • 
                    
  • 第三世界 — 来！给你一次重新投胎的机会
                        沧的海

                        
    一、投胎系统用户可自行选择来生的方方面面，包括国度、家庭、事业、技能、容貌、寿命等等；赢利点来了：选择好的方面自然要付出一定的代价啦，比如更长的寿命、更好的容貌等等；二、生活系统投胎转世后即进入生活系统，生活系统包括：1、设施系统街头、旅游、KTV、电影院、酒吧、餐厅…世界的一开始、即原始时期是没有这些设施的，官方只提供土地资源，开放接口给第三方开发者，集众力、创世界；2、任务系统你可以在此发布或
    
                    
    • 
                    
  • 俏皮的小狗狗
                        三3班_张诗雅_张诗萱

                        
    今天下午微风习习，天阴沉沉的，妈妈带我去幼儿园门口练自行车。练着练着，我看到一只特别可爱的小狗狗，从我身边跑过。他有一身橘黄色的皮毛。尖尖的耳朵非常灵敏，只要他听到风吹草动，都会好奇的四处张望。他的眼睛水灵灵的，像两颗宝石一样闪烁着耀眼的光芒，看上去炯炯有神。他还有一条又粗又有劲的尾巴，走路的时候一翘一翘的，有时还摆尾巴呢！他就像童话中的潇洒的狗王子，又俏皮又可爱，还很英俊，我非常喜欢他。
    
                    
    • 
                    
  • 爬虫技术抓取网站数据
                        Bearjumpingcandy
爬虫
                        
    爬虫技术是指通过程序自动访问网页并提取数据的技术。一般来说，爬虫技术包含以下几个步骤：确定目标网站：确定需要抓取的网站，并了解其页面结构和数据特点。分析页面结构：分析网页的结构和源代码，找到需要抓取的数据在页面中的位置和标识。编写爬虫程序：使用编程语言（如Python）编写爬虫程序，实现对目标网站的自动访问和数据提取。处理抓取数据：对抓取到的数据进行清洗、去重、整合等处理，以便后续的分析和利用。爬
    
                    
    • 
                    
  • 2018-05-24
                        石竹花开

                        
    一明演说故事板块第1讲：一种软实力叫讲故事分享：1.好的销售不是卖产品，而是卖故事；2.让别人接受自己的观点是讲故事的目的；3.真诚，真情实感的故事才能凝聚人，实现整合。图片发自App
    
                    
    • 
                    
  • 掌中星
                        江封时

                        
    chapter.1易言相信，林半星会是他人生中最美丽的一个意外。对，意外。青春里的意外。第一次遇见林半星，是在学校门口拐弯处的停车棚。由于大家基本上都不想挤公交又不情愿步行到学校，从上学期开始就有许多学生骑自行车过来，于是就有了这个学校临时搭建的简陋的停车棚。易言家的小店和小屋子在学校对街，虽然离学校不远，但他讨厌步行，为了方便，还是骑上了父亲的有些年头的黑色自行车。黑色自行车甚至还没有街边的共享
    
                    
    • 
                    
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变
                        黑金IT
fastapi微服务fastapi架构
                        
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
    
                    
    • 
                    
  • Kafka详细解析与应用分析
                        芊言芊语
kafka分布式
                        
    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
    
                    
    • 
                    
  • 整合孩子大脑，培养幸福能力
                        维娅丫

                        
    图片发自App幸福是一种能力，一种解决问题的能力。为人父母，我们要具备足够的能力去培养一个健康、快乐的孩子。在日常生活中，每一个人都会遇到各种各样的问题、困惑、烦恼、挫折，怎样才能化悲伤为开心，化愤怒为力量，坚定的向我们的幸福出发呢？下面，我就谈一下如何帮助孩子整合大脑，培养孩子获得幸福的能力。是什么塑造了我们的大脑呢？———体验。甚至到了老年，体验也仍然在改变着大脑的生理结构。每经历一次体验，一
    
                    
    • 
                    
  • Kafka 基础与架构理解
                        StaticKing
KAFKAkafka
                        
    目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • uniapp实现IM即时通讯仿微信聊天功能
                        即构开发者

                        
    本文介绍如何基于UNIAPP使用即时通讯SDKZIMSDK快速实现基本的消息收发功能。1uniappim即时通讯功能方案介绍即时通讯SDKZIMSDK提供了如下接入方案：image.png在此方案中，您需要通过您自己的业务系统实现以下业务逻辑：搭建客户端的用户管理逻辑，并下发用户ID用于客户端登录。鉴权Token，建议由您的业务后台自行实现，保证鉴权数据安全。uni-appSDK是一个基于原生iO
    
                    
    • 
                    
  • mysql case 干货
                        lack倪酱

                        
    这是我舍友@某人提供的是为了做酒店时判断每个楼栋有几间空房子的。房间表与数据楼栋表与数据查询楼栋房间总数查询空房间数当时就在想怎么把后一个单列的数据合并到前面那三列的数据里呢？又是百度，又是谷歌，都是什么“unitall”。。表示我要的不是这个。有点难为我小脑瓜，实在是对数据库不了解，只会日常操作。最后是我舍友想出了解决办法直接贴图好了，如果想要了解case是什么，你可以自行查资料。学习查东西也是
    
                    
    • 
                    
  • LVGL 控件之列表（lv_list）
                        Projectsauron
#LVGlLVGL嵌入式
                        
    目录一、概述二、列表1、添加列表按钮2、设置列表文本3、API函数一、概述List（列表）基本上是一个垂直布局的矩形，按钮指向该矩形并且可以添加文本。列表部件由两个部分组成：LV_PART_MAIN使用所有典型背景属性的列表的主要部分LV_PART_SCROLLBAR滚动条。二、列表1、添加列表按钮在默认的情况下，列表部件被创建出来后，只有一个矩形背景框，并没有任何的文本和按钮，用户需要自行往列表
    
                    
    • 
                    
  • 关于测试的个人理解
                        低调_0c1d

                        
    针对测试，专业的知识可以自行百度我只谈谈我目前的理解：我目前理解的测试包含两方面：单元测试和集成测试我理解的单元测试是，以一个类的一个方法的单元测试为例，我只关心方法是要干什么的，输入是什么，预期输出是什么，将预期输出和实际的输出进行比对（用志勇哥说的断言），想必有些同学可能会说如果这方法依赖了其他的类，那么此时就可以使用睿哥说的mockito了，我理解的mock就是伪造处一个被依赖的类的方法的输
    
                    
    • 
                    
  • 三维人生
                        墨尽言

                        
    这是我第一篇文章，说实在的，我也不知道该写点什么。其实在这里，永远都都有比自己强的人，也都会有后来居上者。其实，这又怎样？我们总有别人没有经历过的人生，总有别人不熟悉的技能。最近，我试着把个人努力思考的方向转换至另一面，我暂且将它称之为“三维人生”。何为三维人生呢？相信大家都听说过三维这个词吧，一般通常指的是空间上的三维（也可以自行百度一下），那因为我经常接触到三维软件。在软件中，会给你标示出一个
    
                    
    • 
                    
  • 全能第三方支付对接pay-java-parent 2.12.7 发布,支付聚合
                        egzosn
支付第三方支付支付聚合支付对接支付pay微信
                        
    全能第三方支付对接Java开发工具包.优雅的轻量级支付模块集成支付对接支付整合（微信,支付宝,银联,友店,富友,跨境支付paypal,payoneer(P卡派安盈)易极付）app,扫码,网页支付刷卡付条码付刷脸付转账服务商模式、支持多种支付类型多支付账户，支付与业务完全剥离，简单几行代码即可实现支付，简单快速完成支付模块的开发，可轻松嵌入到任何系统里目前仅是一个开发工具包（即SDK），只提供简单W
    
                    
    • 
                    
  • 全面指南：用户行为从前端数据采集到实时处理的最佳实践
                        数字沉思
营销流量运营系统架构前端内容运营大数据
                        
    引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信
    
                    
    • 
                                
  • Js函数返回值
                                    _wy_
jsreturn
                                    
    一、返回控制与函数结果，语法为：return 表达式;作用: 结束函数执行，返回调用函数，而且把表达式的值作为函数的结果 二、返回控制语法为：return;作用: 结束函数执行，返回调用函数，而且把undefined作为函数的结果 在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为.例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性
    
                                
    • 
                                
  • MySQL 的 char 与 varchar
                                    bylijinnan
mysql
                                    
     
今天发现，create table 时，MySQL 4.1有时会把 char 自动转换成 varchar 
 
测试举例： 
 

CREATE TABLE `varcharLessThan4` (
  `lastName` varchar(3)
) ;

mysql> desc varcharLessThan4;
+----------+---------+------+-
    
                                
    • 
                                
  • Quartz——TriggerListener和JobListener
                                    eksliang
TriggerListenerJobListenerquartz
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2208624 一.概述 
listener是一个监听器对象，用于监听scheduler中发生的事件，然后执行相应的操作；你可能已经猜到了，TriggerListeners接受与trigger相关的事件，JobListeners接受与jobs相关的事件。 
  二.JobListener监听器 
 j
    
                                
    • 
                                
  • oracle层次查询
                                    18289753290
oracle；层次查询；树查询
                                    
    .oracle层次查询(connect  by) 
oracle的emp表中包含了一列mgr指出谁是雇员的经理，由于经理也是雇员，所以经理的信息也存储在emp表中。这样emp表就是一个自引用表，表中的mgr列是一个自引用列，它指向emp表中的empno列，mgr表示一个员工的管理者， 
select   empno,mgr,ename,sal  from e
    
                                
    • 
                                
  • 通过反射把map中的属性赋值到实体类bean对象中
                                    酷的飞上天空
javaee泛型类型转换
                                    
    使用过struts2后感觉最方便的就是这个框架能自动把表单的参数赋值到action里面的对象中 
但现在主要使用Spring框架的MVC，虽然也有@ModelAttribute可以使用但是明显感觉不方便。 
好吧，那就自己再造一个轮子吧。 
原理都知道，就是利用反射进行字段的赋值，下面贴代码 
主要类如下： 
  
import java.lang.reflect.Field;
imp
    
                                
    • 
                                
  • SAP HANA数据存储：传统硬盘的瓶颈问题
                                    蓝儿唯美
HANA
                                    
    SAPHANA平台有各种各样的应用场景，这也意味着客户的实施方法有许多种选择，关键是如何挑选最适合他们需求的实施方案。 
在 《Implementing SAP HANA》这本书中，介绍了SAP平台在现实场景中的运作原理，并给出了实施建议和成功案例供参考。本系列文章节选自《Implementing SAP HANA》，介绍了行存储和列存储的各自特点，以及SAP HANA的数据存储方式如何提升空间压
    
                                
    • 
                                
  • Java Socket 多线程实现文件传输
                                    随便小屋
javasocket
                                    
            高级操作系统作业，让用Socket实现文件传输，有些代码也是在网上找的，写的不好，如果大家能用就用上。 
客户端类： 
  
package edu.logic.client;

import java.io.BufferedInputStream;
import java.io.Buffered
    
                                
    • 
                                
  • java初学者路径
                                    aijuans
java
                                    
    学习Java有没有什么捷径?要想学好Java，首先要知道Java的大致分类。自从Sun推出Java以来，就力图使之无所不包，所以Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版，主要用于桌面应用软件的编程；J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；J2EE
    
                                
    • 
                                
  • APP推广
                                    aoyouzi
APP推广
                                    
    一，免费篇 
1，APP推荐类网站自主推荐 
最美应用、酷安网、DEMO8、木蚂蚁发现频道等,如果产品独特新颖，还能获取最美应用的评测推荐。PS：推荐简单。只要产品有趣好玩，用户会自主分享传播。例如足迹APP在最美应用推荐一次，几天用户暴增将服务器击垮。 
2，各大应用商店首发合作 
老实盯着排期，多给应用市场官方负责人献殷勤。 
3，论坛贴吧推广 
百度知道，百度贴吧，猫扑论坛，天涯社区，豆瓣（
    
                                
    • 
                                
  • JSP转发与重定向
                                    百合不是茶
jspservletJava Webjsp转发
                                    
      
在servlet和jsp中我们经常需要请求,这时就需要用到转发和重定向; 
  
转发包括;forward和include   
  
例子;forwrad转发;  将请求装法给reg.html页面 
  
关键代码; 
   
   req.getRequestDispatcher("reg.html
    
                                
    • 
                                
  • web.xml之jsp-config
                                    bijian1013
javaweb.xmlservletjsp-config
                                    
    1.作用：主要用于设定JSP页面的相关配置。 
2.常见定义： 
<jsp-config>
 <taglib>
  <taglib-uri>URI(定义TLD文件的URI,JSP页面的tablib命令可以经由此URI获取到TLD文件)</tablib-uri>
  <taglib-location>
   TLD文件所在的位置

    
                                
    • 
                                
  • JSF2.2 ViewScoped Using CDI
                                    sunjing
CDIJSF 2.2ViewScoped
                                    
    JSF 2.0 introduced annotation @ViewScoped; A bean annotated with this scope maintained its state as long as the user stays on the same view(reloads or navigation - no intervening views). One problem w
    
                                
    • 
                                
  • 【分布式数据一致性二】Zookeeper数据读写一致性
                                    bit1129
zookeeper
                                    
    很多文档说Zookeeper是强一致性保证，事实不然。关于一致性模型请参考http://bit1129.iteye.com/blog/2155336 
  
  Zookeeper的数据同步协议 
Zookeeper采用称为Quorum Based Protocol的数据同步协议。假如Zookeeper集群有N台Zookeeper服务器(N通常取奇数，3台能够满足数据可靠性同时
    
                                
    • 
                                
  • Java开发笔记
                                    白糖_
java开发
                                    
    1、Map<key,value>的remove方法只能识别相同类型的key值 
  
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1,"a");
map.put(2,"b");
map.put(3,"c"
    
                                
    • 
                                
  • 图片黑色阴影
                                    bozch
图片
                                    
     .event{ padding:0;    width:460px;    min-width: 460px;    border:0px solid #e4e4e4;    height: 350px;    min-heig
    
                                
    • 
                                
  • 编程之美-饮料供货-动态规划
                                    bylijinnan
动态规划
                                    
    

import java.util.Arrays;
import java.util.Random;

public class BeverageSupply {

	/**
	 * 编程之美 饮料供货
	 * 设Opt（V’，i）表示从i到n-1种饮料中，总容量为V’的方案中，满意度之和的最大值。
	 * 那么递归式就应该是：Opt（V’，i）=max{ k * Hi+Op
    
                                
    • 
                                
  • ajax大参数（大数据）提交性能分析
                                    chenbowen00
WebAjax框架浏览器prototype
                                    
    近期在项目中发现如下一个问题 
项目中有个提交现场事件的功能，该功能主要是在web客户端保存现场数据（主要有截屏，终端日志等信息）然后提交到服务器上方便我们分析定位问题。客户在使用该功能的过程中反应点击提交后反应很慢，大概要等10到20秒的时间浏览器才能操作，期间页面不响应事件。 
根据客户描述分析了下的代码流程，很简单，主要通过OCX控件截屏，在将前端的日志等文件使用OCX控件打包，在将之转换为
    
                                
    • 
                                
  • [宇宙与天文]在太空采矿,在太空建造
                                    comsci

                                    
         我们在太空进行工业活动...但是不太可能把太空工业产品又运回到地面上进行加工,而一般是在哪里开采,就在哪里加工,太空的微重力环境,可能会使我们的工业产品的制造尺度非常巨大.... 
 
     地球上制造的最大工业机器是超级油轮和航空母舰,再大些就会遇到困难了,但是在空间船坞中,制造的最大工业机器,可能就没
    
                                
    • 
                                
  • ORACLE中CONSTRAINT的四对属性
                                    daizj
oracleCONSTRAINT
                                    
    ORACLE中CONSTRAINT的四对属性 
summary:在data migrate时,某些表的约束总是困扰着我们,让我们的migratet举步维艰,如何利用约束本身的属性来处理这些问题呢?本文详细介绍了约束的四对属性: Deferrable/not deferrable, Deferred/immediate, enalbe/disable, validate/novalidate,以及如
    
                                
    • 
                                
  • Gradle入门教程
                                    dengkane
gradle
                                    
    一、寻找gradle的历程 
一开始的时候，我们只有一个工程，所有要用到的jar包都放到工程目录下面，时间长了，工程越来越大，使用到的jar包也越来越多，难以理解jar之间的依赖关系。再后来我们把旧的工程拆分到不同的工程里，靠ide来管理工程之间的依赖关系，各工程下的jar包依赖是杂乱的。一段时间后，我们发现用ide来管理项程很不方便，比如不方便脱离ide自动构建，于是我们写自己的ant脚本。再后
    
                                
    • 
                                
  • C语言简单循环示例
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int i;
	int count = 0;
	int sum = 0;
	float avg;
	
	for (i=1; i<=100; i++)
	{
		if (i%2==0) 
		{
			count++;
			sum += i;
		}
	}

	avg
    
                                
    • 
                                
  • presentModalViewController 的动画效果
                                    dcj3sjt126com
controller
                                    
    系统自带(四种效果)： 
presentModalViewController模态的动画效果设置：        
[cpp]  
view plain 
copy       
 
 UIViewController *detailViewController = [[UIViewController al
    
                                
    • 
                                
  • java 二分查找
                                    shuizhaosi888
二分查找java二分查找
                                    
    需求：在排好顺序的一串数字中，找到数字T 
  
一般解法：从左到右扫描数据，其运行花费线性时间O(N)。然而这个算法并没有用到该表已经排序的事实。 
	/**
	 * 
	 * @param array
	 *            顺序数组
	 * @param t
	 *            要查找对象
	 * @return
	 */
	public stati
    
                                
    • 
                                
  • Spring Security（07）——缓存UserDetails
                                    234390216
ehcache缓存Spring Security
                                    
     
       Spring Security提供了一个实现了可以缓存UserDetails的UserDetailsService实现类，CachingUserDetailsService。该类的构造接收一个用于真正加载UserDetails的UserDetailsService实现类。当需要加载UserDetails时，其首先会从缓存中获取，如果缓存中没
    
                                
    • 
                                
  • Dozer 深层次复制
                                    jayluns
VOmavenpo
                                    
    最近在做项目上遇到了一些小问题，因为架构在做设计的时候web前段展示用到了vo层，而在后台进行与数据库层操作的时候用到的是Po层。这样在业务层返回vo到控制层，每一次都需要从po-->转化到vo层，用到BeanUtils.copyProperties(source, target)只能复制简单的属性，因为实体类都配置了hibernate那些关联关系，所以它满足不了现在的需求，但后发现还有个很
    
                                
    • 
                                
  • CSS规范整理（摘自懒人图库）
                                    a409435341
htmlUIcss浏览器
                                    
       刚没事闲着在网上瞎逛，找了一篇CSS规范整理，粗略看了一下后还蛮有一定的道理，并自问是否有这样的规范，这也是初入前端开发的人一个很好的规范吧。 
 
 
一、文件规范 
 
1、文件均归档至约定的目录中。 
 
具体要求通过豆瓣的CSS规范进行讲解： 
 
所有的CSS分为两大类：通用类和业务类。通用的CSS文件，放在如下目录中： 
 
基本样式库 /css/core 

    
                                
    • 
                                
  • C++动态链接库创建与使用
                                    你不认识的休道人
C++dll
                                    
    一、创建动态链接库 
1.新建工程test中选择”MFC [dll]”dll类型选择第二项"Regular DLL With MFC shared linked"，完成 
2.在test.h中添加 
extern “C” 返回类型 _declspec(dllexport)函数名(参数列表); 
3.在test.cpp中最后写 
 
extern “C” 返回类型 _decls
    
                                
    • 
                                
  • Android代码混淆之ProGuard
                                    rensanning
ProGuard
                                    
    Android应用的Java代码，通过反编译apk文件（dex2jar、apktool）很容易得到源代码，所以在release版本的apk中一定要混淆一下一些关键的Java源码。 
 
ProGuard是一个开源的Java代码混淆器（obfuscation）。ADT r8开始它被默认集成到了Android SDK中。 
 
官网： 
http://proguard.sourceforge.net/
    
                                
    • 
                                
  • 程序员在编程中遇到的奇葩弱智问题
                                    tomcat_oracle
jquery编程ide
                                    
    　　现在收集一下： 
   
  
  
　　排名不分先后，按照发言顺序来的。 
  
1、Jquery插件一个通用函数一直报错，尤其是很明显是存在的函数，很有可能就是你没有引入jquery。。。或者版本不对 
2、调试半天没变化：不在同一个文件中调试。这个很可怕，我们很多时候会备份好几个项目，改完发现改错了。有个群友说的好：   在汤匙
    
                                
    • 
                                
  • 解决maven-dependency-plugin (goals "copy-dependencies","unpack") is not supported
                                    xp9802
dependency
                                    
    解决办法：在plugins之前添加如下pluginManagement，二者前后顺序如下： 
     
[html]  
view plain 
copy       
 
 <build>   
         <pluginManagement
    
                                
    •