提出需求

相信很多时候，你可能有这样的需求，比如A对象的属性1、属性2是你需要的，其余属性是空值，而B对象的属性3、属性4是你需要的，其余属性是空值，那么如何将A对象的属性与B对象的属性结合呢？

思路解析

要实现将两个对象的属性结合，需要用到反射技术，遍历每个对象的属性，将非null的属性复制给null的属性，最后实现合并属性的效果。

常用的复制对象属性的方法（传统方案）

使用Java Bean Utils，这是Apache Commons BeanUtils库中的一个工具类，使用此工具类，则需要自己去实现判断属性的业务逻辑。

这个工具类有两个复制属性的方法，copyProperties和copyProperty。

copyProperties方法会将orig（第二个对象）的属性复制给dest（第二个对象），这种复制是完全复制，会完全覆盖dest的属性。

copyProperty方法将复制value给bean的特定属性。

hutool合并对象的方案

Hutool是一个Java工具包类库，对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装，组成各种Util工具类。

hutool常常被广大spring程序员唾弃，抱怨其在项目中的稳定性，bug问题。但我认为，hutool是一个在不断迭代和维护的库，虽然是国内程序员开发的，但是其中很多功能仍然是简单好用的，不能够以偏概全的全面否定它。

回归正题，下面做详细的说明

pom导入合并对象所必须的hutool库

<dependency>

    <groupId>cn.hutool</groupId>

    <artifactId>hutool-core</artifactId>

    <version>5.8.16</version>

</dependency>

方法解释

• cn.hutool.core.bean.BeanUtil

hutool的复制对象方法copyProperties有4个重载类型，在apache common beanutils的基础上，增加了一些复制选项，这些选项是非常实用的，比如忽略大小写、忽略某些属性、某些特定的复制选项等。

copyProperties(Object source, Object target, CopyOptions copyOptions)

因为我实际用了copyProperties(Object source, Object target, CopyOptions copyOptions)，重点讲解此方法的传入参数。

CopyOptions包括以下的一些属性或选项，可以根据你的项目需求来选择

自己写的合并工具类

该工具类仅供参考，可以根据自己情况调整

public class MergeUtil {

    private static final CopyOptions options = CopyOptions.create().setIgnoreNullValue(true).setOverride(false);

    private static final CopyOptions optionsAllowOverride = CopyOptions.create().setIgnoreNullValue(true).setOverride(true);



    //将sourceBean中的属性合并到tagetBean，忽略Null值，非Null值不允许覆盖

    public static Object merge(Object sourceBean, Object targetBean) {

        BeanUtil.copyProperties(sourceBean, targetBean, options);



        return targetBean;

    }



    //将sourceBean中的属性合并到tagetBean，忽略Null值，非Null值允许覆盖

    public static Object mergeAllowOverride(Object sourceBean, Object targetBean) {

        BeanUtil.copyProperties(sourceBean, targetBean, optionsAllowOverride);



        return targetBean;

    }

}

前言

自从我看冯唐老师推荐的《资治通鉴》之后，对历史有那么一丢丢的兴趣，直到在短视频里面刷到《百家讲坛》里面几位老师的讲解片段，以及跟自己经历结合，瞬间满满的共鸣，是啊时代一直在变化，而里面的为人处事、社会规则凡此种种却从来没有太大变化，这就是我们需要去学习历史的原因。

所以有了以下感慨。

<<百家讲坛>> 不愧是经典，整本历史歪歪斜斜写着两字：权谋，谋事、谋人，加上不确定因素，天时地利人和，最终变成命运。
人的一生就像书中一行字轻描淡写，绘成一笔～

人需借以虚名而成事

这里解释一下，人需要倚靠外部的这些名号、头衔从而能有比较大的作为。为什么这么讲呢，听我细细道来～

人生需要四行

这是王立群老师讲的，人生要想有点成就需要四行，首先你自己行，你自身本身够硬，能够做好事，其次是有人说你行，从古代的推荐机制，比如说优秀的人推荐其他优秀的人才对不对，李白的大名远扬，唐玄宗在公主引荐之下见了皇帝，第三个说你行的人要行，推荐你的那个人本身能力要强，不然没有说服力，第四是身体行，很多机会是熬出来的，比如司马懿伺候了3位君主，兢兢业业，最终才能完成自己的大业。

何为借以虚名？

1、刘备的例子，他在比较年长的时候还无法实现自己的基业，寄人篱下，他登场的时候是怎样的呢，名号叫刘皇叔，翻开长长的祖谱，八辈子打不到杆哈哈哈，不过因为当时被曹操挟持，所以需要有汉族帮忙自己，所以顺理成章的提拔上来。

2、项羽出生在一个贵族家庭。他的父亲项梁是楚国将领，曾经在楚汉战争中和刘邦一起作战。而他的母亲也是楚国的贵族，是楚王的女儿。

相比之下，刘邦的出身则比较低微。他的祖父是一个农民，父亲是一个小县官。他自己也曾经当过一个普通的县尉，但因为功绩不够而被罢免。

尽管项羽出身高贵，但他的性格比较豁达，喜欢豪情壮志和享乐人生，行事大胆不拘小节。刘邦则更加谨慎稳重，注重政治规划和长远发展。

3、王立群老师讲述过他自身的故事，小学的时候成绩优秀得到保送，后面名额被学校给了别人，自己去了私立的学校，半工半读，到了大学还是遇到了同样的遭遇，后面就到比较好的大学教书，但是有一天校长跟他讲他的成绩还是出身问题需要去另一所低一点的学校教书，他当时就哭了，命运比较坎坷的。

4、工作中，我们常常会听到，某位领导自我介绍某某大厂经历，还有某某大学毕业，还有当你投一些大厂的核心部门的时候，都会对你学历进行考核。

所以我们从上面3个例子来看，人生确实正如王立群老师讲的，需要四行，当你自己不行的时候，即使有机会也会最终流失掉；当没有推荐你的时候，也会埋没在茫茫人海中，并不是说是金子总会发光，现实是伯乐更加重要；当说你行的人没有能力的时候也不行，名牌大学、大厂经历也是这样，通过一个有名声的物体从而表示你也可以，也很厉害哈哈；最后身体是本钱，这个就不用过多的讲解了。

读历史的目的，从前人的故事、经历中，学习到点什么，化为自身的经验、阅历。

我发现现在很多人都喜欢出去玩，说的开阔视野，扩展见识，在我看来读历史才是真正的拓宽自己的眼界，原来几百年前也有人跟我一样遇到同样的问题，也有那些胸怀大志的三国名将郁郁不得志。

历史是一本书籍，它可以很薄，几句话、几行字就概括了一个朝代，它也可以很厚，厚到整个朝代的背景，比如气候情况、经济情况、外交情况、内政情况，各个出名的人物事迹，那岂是几页纸能讲得完的，是多么的厚重。

如果人不能借以虚名怎么做事？

修炼两件事情

同样百家讲坛也给出了一个比较好的见解，一个人想要成事，需要两个明，一个是高明、一是精明。高明是你有足够的眼光去发现，发现机会也好，发现危机也好，往往人生的成就需要这种高瞻远瞩的；另一个精明，是指在做事上打磨，细心主动，王阳明讲的知行合一，里面很关键的一点就是事上练，方法论在实战中去验证总结。

心态上练

李连杰在采访中说了这么一个耐人寻味的故事，他发现不管是有钱的人还是没有钱的人都会生气，比如一些老板在为几百万损失破口大骂，也有人因为几万的丢失是否生气，也有人丢了几块钱很愤怒。他觉得人都会愤怒，只是那个导致他愤怒的级别不一样而已。

他早年给自己定目标，发现当达到目标之后，发现还是有人比自己厉害，所以即使达到目标也没有想象快乐；即使有钱人无法解决痛苦的问题，比如生老病死。

所以人生意义在哪里？

我认为如果你奔着成事的想法，多修炼上面两件事，如果没有发展机会，不如躺平，积累自己的能力，就像道德经里面的无为而为，而心态的修炼是人生终极修炼，因为生死才是人生最大的难关，人应该怎么脱离时间束缚，不受衰老影响。

恰恰历史给了我们启示，要有所作为，能够为人类历史上留下精神粮食，做出浓厚贡献，就像我们都没有见过孔子、老子吧，但是他们的精神至今都在影响着我们。

用了那么久的Upload组件，你知道是怎么实现的么，今天就来仿写一个饿了么el-upload vue组件，彻底搞懂前端的文件上传相关知识！

要实现的props

参考：element.eleme.cn/#/zh-CN/com…

这里面有几个重要的点：

1. input file 的美化


2. 多选


3. 拖拽

一个个实现

创建upload组件文件

src/components/upload/index.vue

<template></template>

<script setup>

  // 属性太多，把props单独放一个文件引入进来

  import property from './props'

  const props = defineProps(property)

</script>

<style></style>

./props.js

export default {

  action: {

    type: String

  },

  headers: {

    type: Object,

    default: {}

  },

  multiple: {

    type: Boolean,

    default: false

  },

  data: {

    type: Object,

    default: {}

  },

  name: {

    type: String,

    default: 'file'

  },

  'with-credentials': {

    type: Boolean,

    default: false

  },

  'show-file-list': {

    type: Boolean,

    default: true,

  },

  drag: {

    type: Boolean,

    default: false

  },

  accept: {

    type: String,

    default: ''

  },

  'list-type': {

    type: String,

    default: 'text' // text、picture、picture-card

  },

  'auto-upload': {

    type: Boolean,

    default: true

  },

  'file-list': {

    type: Array,

    default: []

  },

  disabled: {

    type: Boolean,

    default: false

  },

  limit: {

    type: Number,

    default: Infinity

  },

  'before-upload': {

    type: Function,

    default: () => {

      return true

    }

  },

  'before-remove': {

    type: Function,

    default: () => {

      return true

    }

  }

具体的编写upload组件代码

1. 文件上传按钮的样式

我们都知道，<input type="file">的默认样式是这样的： 很丑，并且无法改变其样式。

解决办法：可以把input隐藏，重新写个按钮点击来触发input的文件选择。

<template>

  <input 

     type="file" 

     id="file" 

     @change="handleChange"

  >

  <button 

     class="upload-btn" 

     @click="choose"

  >

    点击上传

  </button>

</template>

<script setup>

  // 触发选择文件

  const choose = () => {

    document.querySelector('#file').click()

  }

  // input选择文件回调

  const handleChange = (event) => {

    files = Array.from(event.target.files)

    console.log('[ files ] >', files)

  }

</script>

<style scoped>

  #file {

    display: none;

  }

  .upload-btn {

    border: none;

    background-color: #07c160;

    color: #fff;

    padding: 6px 10px;

    cursor: pointer;

  }

</style>

效果：

这样也是可以调起文件选择框，并触发input的onchange事件。

2. 多选

直接在input上加一个Booelan属性multiple，根据props中的值动态设置

顺便把accept属性也加上

<template>

  <input 

     type="file" 

     id="file" 

     :multiple="multiple"

     :accept="accept"

     @change="handleChange"

  >

</template>

3. 拖拽

准备一个接收拖拽文件的区域，props传drag=true就用拖拽，否则就使用input上传。

<template>

  <input 

    type="file" 

    id="file" 

    :multiple="multiple"

    :accept="accept"

    @change="handleChange"

  >

  <button 

     class="upload-btn" 

     v-if="!drag" 

     @click="choose"

  >

    点击上传

  </button>

  <div 

    v-else 

    class="drag-box" 

    @dragover="handleDragOver"

    @dragleave="handleDragLeave"

    @drop="handleDrop"

    @click="choose"

    :class="{'dragging': isDragging}"

  >

    将文件拖到此处，或<span>点击上传</span>

  </div>

</template>

dragging用来拖拽鼠标进入时改变样式

<script setup>

  const isDragging = ref(false)

  // 拖放进入目标区域

  const handleDragOver = (event) => {

    event.preventDefault()

    isDragging.value = true

  }

  const handleDragLeave = (event) => {

    isDragging.value = false

  }

  let files = []

  // 拖拽放置

  const handleDrop = (event) => {

    event.preventDefault()

    isDragging.value = false

    files = Array.from(event.dataTransfer.files);

    console.log(files);

  }

</script>

.drag-box {

    width: 240px;

    height: 150px;

    line-height: 150px;

    text-align: center;

    border: 1px dashed #ddd;

    cursor: pointer;

    border-radius: 8px;

  }

  .drag-box:hover {

    border-color: cornflowerblue;

  }

  .drag-box.dragging {

    background-color: rgb(131, 161, 216, .2);

    border-color: cornflowerblue;

  }

  .drag-box span {

    color: cornflowerblue;

  }

跟使用input上传效果一样

4. 上传到服务器

并实现on-xxx钩子函数

  const emit = defineEmits()

  const fileList = ref([])

  let files = []



  // 拖拽放置

  const handleDrop = (event) => {

    event.preventDefault()

    isDragging.value = false

    files = Array.from(event.dataTransfer.files);

    console.log('[ files ] >', files)

    handleBeforeUpload(files)

  }



  // input选择文件回调

  const handleChange = (event) => {

    files = Array.from(event.target.files)

    console.log('[ files ] >', files)

    handleBeforeUpload(files)

  }



  const handleBeforeUpload = (files) => {

    if (files.length > props.limit - fileList.value.length) {

      console.error(`当前限制选择 ${props.limit} 个文件，本次选择了 ${files.length} 个文件，共选择了 ${files.length + fileList.value.length} 个文件`)

      emit('on-exceed', files, toRaw(fileList.value))

      return

    }

    // 可以把锁哥文件放到一个formData中一起上传，

    // 遍历文件一个个上传，这里一个个上传是为了实现钩子函数回调时返回对应的file对象。

    files.forEach(async file => {

      emit('on-change', file, files)

      if (!props.beforeUpload()) {

        return

      }

      if (props.autoUpload) {

        uploadRequest(file, files)

      }

    })

  }



  // 手动上传已选择的文件

  const submit = () => {

    files.forEach(async file => {

      uploadRequest(file, files)

    })

  }

  

  // 保存xhr对象，用于后面取消上传

  let xhrs = []

  const uploadRequest = async (file, files) => {

    let xhr = new XMLHttpRequest();

    // 调用open函数，指定请求类型与url地址。请求类型必须为POST

    xhr.open('POST', props.action);

    // 设置自定义请求头

    Object.keys(props.headers).forEach(k => {

      xhr.setRequestHeader(k, props.headers[k])

    })

    // 额外参数

    const formData = new FormData()

    formData.append('file', file);

    Object.keys(props.data).forEach(k => {

      formData.append(k, props.data[k]);

    })

    // 携带cookie

    xhr.withCredentials = props.withCredentials

    xhr.upload.onprogress = (e) => {

      emit('on-progress', e, file, files)

    }

    // 监听状态

    xhr.onreadystatechange = () => {

      if (xhr.readyState === 4) {

        const res = JSON.parse(xhr.response)

        const fileObj = {

          name: file.name,

          percentage: 100,

          raw: file,

          response: res,

          status: 'success',

          size: file.size,

          uid: file.uid,

        }

        fileList.value.push(fileObj)

        if (xhr.status === 200 || xhr.status === 201) {

          emit('on-success', res, fileObj, toRaw(fileList.value))

        } else {

          emit('on-error', res, fileObj, toRaw(fileList.value))

        }

      }

    }

    // 发起请求

    xhr.send(formData);

    xhrs.push({

      xhr,

      file

    })

  }



  const preview = (file) => {

    emit('on-preview', file)

  }



  const remove = (file, index) => {

    if (!props.beforeRemove()) {

      return

    }

    fileList.value.splice(index, 1)

    emit('on-remove', file, fileList.value)

  }



  // 取消上传

  const abort = (file) => {

    // 通过file对象找到对应的xhr对象，然后调用abort

    // xhr.abort()

  }



  defineExpose({

    abort,

    submit

  })

全部代码

<template>

  <input 

    type="file" 

    id="file" 

    :multiple="multiple"

    :accept="accept"

    @change="handleChange"

  >

  <button class="upload-btn" v-if="!drag" @click="choose">

    点击上传

  </button>

  <div 

    v-else 

    class="drag-box" 

    @dragover="handleDragOver"

    @dragleave="handleDragLeave"

    @drop="handleDrop"

    @click="choose"

    :class="{'dragging': isDragging}"

  >

    将文件拖到此处，或<span>点击上传</span>

  </div>

  <template v-if="showFileList">

    <template v-if="listType === 'text'">

      <p class="file-item" v-for="(file, index) in fileList" :key="index" @click="preview(file)">

        <span>{{file.name}}</span>

        <span class="remove" @click.stop="remove(file, index)">×</span>

      </p>

    </template>

  </template>

</template>



<script setup>

  import { ref, toRaw, onMounted } from 'vue'

  import property from './props'

  const props = defineProps(property)

  const emit = defineEmits()



  const fileList = ref([])

  const isDragging = ref(false)



  // 触发选择文件

  const choose = () => {

    document.querySelector('#file').click()

  }



  // 拖放进入目标区域

  const handleDragOver = (event) => {

    event.preventDefault()

    isDragging.value = true

  }



  const handleDragLeave = (event) => {

    isDragging.value = false

  }



  let files = []



  // 拖拽放置

  const handleDrop = (event) => {

    event.preventDefault()

    isDragging.value = false

    files = Array.from(event.dataTransfer.files);

    console.log('[ files ] >', files)

    handleBeforeUpload(files)

  }



  // input选择文件回调

  const handleChange = (event) => {

    files = Array.from(event.target.files)

    console.log('[ files ] >', files)

    handleBeforeUpload(files)

  }



  const handleBeforeUpload = (files) => {

    if (files.length > props.limit - fileList.value.length) {

      console.error(`当前限制选择 ${props.limit} 个文件，本次选择了 ${files.length} 个文件，共选择了 ${files.length + fileList.value.length} 个文件`)

      emit('on-exceed', files, toRaw(fileList.value))

      return

    }

    files.forEach(async file => {

      emit('on-change', file, files)

      if (!props.beforeUpload()) {

        return

      }

      if (props.autoUpload) {

        uploadRequest(file, files)

      }

    })

  }



  // 手动上传已选择的文件

  const submit = () => {

    files.forEach(async file => {

      uploadRequest(file, files)

    })

  }



  let xhrs = []

  const uploadRequest = async (file, files) => {

    let xhr = new XMLHttpRequest();

    // 调用open函数，指定请求类型与url地址。请求类型必须为POST

    xhr.open('POST', props.action);

    // 设置自定义请求头

    Object.keys(props.headers).forEach(k => {

      xhr.setRequestHeader(k, props.headers[k])

    })

    // 额外参数

    const formData = new FormData()

    formData.append('file', file);

    Object.keys(props.data).forEach(k => {

      formData.append(k, props.data[k]);

    })

    // 携带cookie

    xhr.withCredentials = props.withCredentials

    xhr.upload.onprogress = (e) => {

      emit('on-progress', e, file, files)

    }

    // 监听状态

    xhr.onreadystatechange = () => {

      if (xhr.readyState === 4) {

        const res = JSON.parse(xhr.response)

        const fileObj = {

          name: file.name,

          percentage: 100,

          raw: file,

          response: res,

          status: 'success',

          size: file.size,

          uid: file.uid,

        }

        fileList.value.push(fileObj)

        if (xhr.status === 200 || xhr.status === 201) {

          emit('on-success', res, fileObj, toRaw(fileList.value))

        } else {

          emit('on-error', res, fileObj, toRaw(fileList.value))

        }

      }

    }

    // 发起请求

    xhr.send(formData);

    xhrs.push({

      xhr,

      file

    })

  }



  const preview = (file) => {

    emit('on-preview', file)

  }



  const remove = (file, index) => {

    if (!props.beforeRemove()) {

      return

    }

    fileList.value.splice(index, 1)

    emit('on-remove', file, fileList.value)

  }



  // 取消上传

  const abort = (file) => {

    // 通过file对象找到对应的xhr对象，然后调用abort

    // xhr.abort()

  }



  defineExpose({

    abort,

    submit

  })

</script>



<style scoped>

  #file {

    display: none;

  }

  .upload-btn {

    border: none;

    background-color: #07c160;

    color: #fff;

    padding: 6px 10px;

    cursor: pointer;

  }

  .drag-box {

    width: 240px;

    height: 150px;

    line-height: 150px;

    text-align: center;

    border: 1px dashed #ddd;

    cursor: pointer;

    border-radius: 8px;

  }

  .drag-box:hover {

    border-color: cornflowerblue;

  }

  .drag-box.dragging {

    background-color: rgb(131, 161, 216, .2);

    border-color: cornflowerblue;

  }

  .drag-box span {

    color: cornflowerblue;

  }

  .file-item {

    display: flex;

    justify-content: space-between;

    align-items: center;

    margin-top: 12px;

    padding: 0 8px;

    border-radius: 4px;

    cursor: pointer;

  }

  .file-item:hover {

    background-color: #f5f5f5;

    color: cornflowerblue;

  }

  .file-item .remove {

    font-size: 20px;

  }

</style>

如何使用

<template>

  <upload 

    ref="uploadRef"

    action="http://localhost:3000/upload"

    multiple

    show-file-list

    drag

    auto-upload

    upload-folder

    :headers="headers"

    :data="data"

    :limit="3"

    :before-upload="beforeUpload"

    :before-remove="beforeRemove"

    @on-change="handleChange"

    @on-success="handleSuccess"

    @on-error="handleError"

    @on-preview="handlePreview"

    @on-remove="handleRemove"

    @on-exceed="handleExceed"

    @on-progress="handleProgress"

  >

  </upload>

</template>



<script setup>

  import { ref } from 'vue'

  import upload from '@/components/upload/index.vue'



  const uploadRef = ref(null)



  const data = {

    name: '张三',

    age: 20

  }



  const headers = {

    a: 111

  }



  const handleChange = (file, fileList) => {

    // console.log('onChange', file, fileList)

  }

  const handleSuccess = (res, file, fileList) => {

    console.log(res, file, fileList)

  }

  const handleError = (err, file, fileList) => {

    console.log(err, file, fileList)

  }

  const handlePreview = (file) => {

    console.log('handlePreview', file)

  }

  const handleRemove = (file, fileList) => {

    console.log('handleRemove', file, fileList)

  }

  const handleExceed = (files, fileList) => {

    console.log('文件个数超限', files, fileList)

  }

  const handleProgress = (e, file, fileList) => {

    console.log('上传进度');

    if (e.lengthComputable) {

      const percentComplete = Math.ceil((e.loaded / e.total) * 100)

      console.log('[ percentComplete ] >', percentComplete)

    }

  }

  const beforeUpload = (file) => {

    return true

  }

  const beforeRemove = (file, fileList) => {

    return true

  }

</script>



<style>



</style>

前面写了一篇仿写el-upload组件，彻底搞懂文件上传，实现了选择/拖拽文件上传，我们经常看到一些网站支持直接选择整个文件夹上传，例如：宝塔面板、cloudflare托管、对象存储网站等等需要模拟文件路径存储文件的场景。那是怎么实现的呢？

依然从两方面来说：

1. input选择文件夹


2. 拖拽文件夹

input选择文件夹

在props.js中加一个属性，upload-folder是否支持上传文件夹

export default {

  // 前面的省略了...

  // 是否支持选择文件夹

  'upload-folder': {

    type: Boolean,

    default: false

  }

}

改一下input标签，依然是根据props的值动态判断是否支持上传文件夹。主要是webkitdirectory这个属性，由于不是一个标准属性，需要加浏览器前缀。

<input 

  type="file" 

  id="file" 

  :multiple="multiple"

  :accept="accept"

  :webkitdirectory="uploadFolder"

  :mozdirectory="uploadFolder"

  :odirectory="uploadFolder"

  @change="handleChange"

>

注意：支持选择文件夹时就只能选择文件夹，无法选择文件。

那么如何获取选择的文件夹呢？其实我们最终要上传的依然是文件，也就是file对象，文件夹也是一个特殊的文件。

依然是通过input的onchange事件回调拿到上传的event。

或者直接获取input这个dom对象，然后拿到files属性，结果是一样的。

// input选择文件回调

const handleChange = (event) => {

  console.log('[ files ] >', event.target.files)

  const inputDom = document.querySelector('#file')

  console.log('[ files ] >', inputDom.files)

}

可以看到，比选择单个文件时，多了一个webkitRelativePath属性，并且它是递归选择的文件夹，拿到这个文件夹及其子文件夹下所有的文件，我们可以通过这个属性拿到上传时文件所在的文件夹名称和路径。

拖拽文件夹

上篇文章讲过拖拽如何拿到文件，首先要准备一个用于拖拽放置的区域。
调用upload组件时，传入drag=true。

<div 

  class="drag-box" 

  @dragover="handleDragOver"

  @dragleave="handleDragLeave"

  @drop="handleDrop"

>

  将文件拖到此处，或<span>点击上传span>

div>

// 拖放进入目标区域

const handleDragOver = (event) => {

  event.preventDefault()

}

// 拖拽放置

const handleDrop = (event) => {

  event.preventDefault()

  console.log('[ event ] >', event)

}

注意：和input上传不同，拖拽时，是可以同时拖拽文件和文件夹的。

因为可以同时拖拽文件和文件夹，我们就不能直接使用event.dataTransfer.files，如果刚好拖拽进来的是一个文件，那可以这么获取，如果是个文件夹呢？那就不行了。

这时候就要用到event.dataTransfer.items了

// 拖拽放置

const handleDrop = (event) => {

  event.preventDefault()

  console.log(event.dataTransfer.items)

}

打印一下看看：

得到一个List类型的数据，里面是两个DataTransferItem，控制台无法直接查看它到底是个什么玩意儿。

看MDN，也看不出它具体是个啥。既然是List，遍历一下看看：

const handleDrop = (event) => {

  event.preventDefault()

  console.log(event.dataTransfer.items)

  for (const item of event.dataTransfer.items) {

    console.log('[ item ] >', item)

  }

}

可以看到不管是文件还是文件夹，都被识别成了file，只不过图片是直接能识别出type为image/png。

查看MDN，developer.mozilla.org/zh-CN/docs/…

点击查看item的Prototype，发现里面有个webkitGetAsEntry方法，执行它就能拿到item的具体信息。

看方法名，带了个webkit，但是这个方法除了Android Firefox浏览器以外都可以用。

for (const item of event.dataTransfer.items) {

  const entry = item.webkitGetAsEntry()

  console.log(entry)

}

依然拖动上面那个图片文件和一个文件夹：


可以看出，文件夹里面还有文件和文件夹，但是只显示了一个文件和一个文件夹，看来拖拽和input上传不一样，它不会自动的把里面所有的文件递归列出来。

通过isDirectory属性，就能区分是文件还是文件夹。除了这些基础属性以外，继续查看Prototype，可以看到还有一系列方法：

先看怎么拿到文件

当entry是一个文件时，它有两个方法：createWriter()和file()，查看MDN，developer.mozilla.org/en-US/docs/…

createWriter()已经废弃了，而且也不是我们今天要用的。

file()才是我们要找的。


这不就是我们熟悉的file对象吗，跟input上传拿到的一毛一样。

再看怎么拿到文件夹

查看MDN的Drop API webkitGetAsEntry()方法，developer.mozilla.org/zh-CN/docs/… 可得，如果是文件夹，可以通过createReader方法创建一个文件目录阅读器，然后通过readEntries方法，重新拿到每个item，这就是event.dataTransfer.items里面的每个item。

我们写一下试试

依然是之前那个图片和文件夹

只打印出了跟目录下一级的一个文件和一个文件夹，那下面还有一个文件怎么办呢？

递归呀！

写一个递归读文件的方法。

const readFiles = async (item) => {

  if (item.isDirectory) {

    // 是一个文件夹

    console.log('=======文件夹=======');

    const directoryReader = item.createReader();

    // readEntries是一个异步方法

    const entries = await new Promise((resolve, reject) => {

      directoryReader.readEntries(resolve, reject);

    });



    let files = [];

    for (const entry of entries) {

      const resultFiles = await readFiles(entry);

      files = files.concat(resultFiles);

    }

    return files;

  } else {

    // 是一个文件

    console.log('=======文件=======');

    // file也是一个异步方法

    const file = await new Promise((resolve, reject) => {

      item.file(resolve, reject);

    });

    console.log('[ file ] >', file);

    return [file];

  }

}

handleDrop方法也要改一下

// 拖拽放置

const handleDrop = async (event) => {

  event.preventDefault()

  console.log(event.dataTransfer.items)



  const files = [];

  const promises = [];

  for (const item of event.dataTransfer.items) {

    const entry = item.webkitGetAsEntry();

    console.log('[ entry ] >', entry);

    promises.push(readFiles(entry));

  }



  const resultFilesArrays = await Promise.all(promises);

  const allFiles = resultFilesArrays.flat();



  console.log('[ All files ] >', allFiles);

}

再次拖拽上传看看

三个文件我们都拿到了。

总结

上传文件夹，还是直接使用input比较简单，使用它能直接拿到文件夹下所有的文件，以及每个文件在本地的路径，代码量也少很多。

拖拽的好处是文件和文件夹能一起上传。

背景

业务当中写Android异步任务一直是一项挑战，以往的回调和线程管理方式比较复杂和繁琐，造成代码难以维护和阅读。在前端领域中JavaScript其实也面临同样的问题，Promise 就是它的比较主流的一种解法。 在尝试使用Promise之前我们也针对Android现有的一些异步做了详细的对比。

文章思维导图

What：什么是Promise？

对于Android开发的同学，可能很多人不太熟悉Promise，它主要是前端的实践，所以先解析概念。
Promise 是 JavaScript 语言提供的一种标准化的异步管理方式，它的总体思想是，需要进行 io、等待或者其它异步操作的函数，不返回真实结果，而返回一个“承诺”，函数的调用方可以在合适的时机，选择等待这个承诺兑现（通过 Promise 的 then 方法的回调）。

最简单例子(JavaScript）

const promise = new Promise(function(resolve, reject) {

  // ... some code



  if (/* 异步操作成功 */){

    resolve(value);

  } else {

    reject(error);

  }

}).then(function(value) {

    console.log('resolved.');

}).catch(function(error) {

    console.log('发生错误！', error);

});

实例化一个Promise对象，构造函数接受一个函数作为参数，该参数分别是resolve和reject。

resolve函数：将Promise 对象状态从pending 变成 resolved

reject函数：将Promise 对象状态从 pending 变成 rejected

then函数：回调 resolved状态的结果
catch函数：回调 rejected状态的结果

可以看到Promise的状态是非常简单且清晰的，这也让它在实现异步编程减少很多认知负担。

Why：为什么要考虑引入Promise

前面说的Promise 不就是 JavaScript 异步编程的一种思想吗，那这跟 Android 开发有什么关系？ 虽然前端和终端领域有所不同，但面临的问题其实是大同小异的，比如常见的异步回调导致回调地狱，逻辑处理不连贯等问题。
从事Android开发的同学应该对以下异步编程场景比较熟悉：

• 单个网络请求


• 多个网络请求竞速


• 等待多个异步任务返回结果


• 异步任务回调


• 超时处理


• 定时轮询

这里可以停顿思考一下，如果利用 Android常规的方式去实现以上场景，你会怎么做？你的脑子可能有以下解决方案：

• 使用 Thread 创建


• 使用 Thread + Looper + Handler


• 使用 Android 原生 AsyncTask


• 使用 HandlerThread


• 使用 IntentService


• 使用 线程池


• 使用 RxJava 框架

以上方案都能在Android中实现异步任务处理，但或多或少存在一些问题和适用场景，我们详细剖析下各自的优缺点：

通过不同的异步实现方式的对比，可以发现每种实现方式都有适用场景，我们面对业务复杂度也是不一样的，每一种解决方案都是为了降低业务复杂度，用更低成本的方式来编码，但我们也知道代码写出来是给人看的，是需要持续迭代和维护，类似RxJava 这种框架于我们而言太复杂了，繁琐的操作符容易写出不易维护的代码，简单易理解应该是更好的追求，而不是炫技，所以我们才会探索用更轻量更简洁的编码方式来提升团队的代码一致性，就目前而言使用 Promise 来写代码将会有以下好处：

• 解决回调地狱：Promise 可以把一层层嵌套的 callback 变成  .then().then()... ，从而使代码编写和阅读更直观


• 易于处理错误：Promise 比 callback 在错误处理上更清晰直观


• 非常容易编写多个异步操作的代码

How：怎么使用 Promise 重构业务代码？

这里由于我们的Java版本的Promise组件未开源，所以本部分只分析重构Case使用案例。

重构case1: 如何实现一个带超时的网络接口请求？

这是一段未重构前的获取付款码的异步代码：

可以看到以上代码存在以下问题：

• 需要定义异步回调接口


• 很多 if-else 判断，圈复杂度较高


• 业务实现了一个超时类，为了不受网络库默认超时影响


• 逻辑不够连贯，不易于维护

使用 Promise重构后：

可以看到有以下变化：

• 消除了异步回调接口，链式调用让逻辑更连贯更清晰了


• 通过 Promise 包装了网络请求调用，统一返回 Promise


• 指定了 Promise 超时时间，无需额外实现繁琐的超时逻辑


• 通过 validate 方法 替代 if - else 的判断，如果需要还可以定义校验规则


• 统一处理异常错误，逻辑变得更加完备

重构case2：如何更优雅的实现长链接降级短链接？

重构前的做法：


代码存在以下问题：

• 处理长链接请求超时，通过回调再处理降级逻辑


• 使用Handler实现定时器轮询请求异步结果并处理回调


• 处理各种逻辑判断，代码难以维护


• 不易于模拟超时降级，代码可测试性差

使用Promise重构后：

第一个Promise处理长链接Push监听 ，设置5s超时，超时异常发生回调except方法，判断throwable 类型，如果为PromiseTimeoutException实例对象，则执行降级短链接。短链接是另外一个Promise，通过这种方式将逻辑都完全结果，代码不会割裂，逻辑更连贯。
短链接轮训查单逻辑使用Promise实现：

• 最外层Promise，控制整体的超时，即不管轮询的结果如何，超过限定时间直接给定失败结果


• Promise.delay()，这个比较细节，我们认定500ms轮询一定不会返回结果，则通过延迟的方式来减少一次轮询请求


• Promise.retry()，真正重试的逻辑，限定了最多重试次数和延时逻辑，RetryStrategy定义的是重试的策略，延迟（delay）多少和满足怎样的条件（condition）才允许重试

这段代码把复杂的延时、条件判断、重试策略都通过Promise这个框架实现了，少了很多临时变量，代码量更少，逻辑更清晰。

重构case3：实现 iLink Push支付消息和短链接轮训查单竞速

后面针对降级策略重构成竞速模型，采用Promise.any很轻松得实现代码重构，代码如下图所示。

总结

本文提供一种异步编程的思路，借鉴了Promise思想来重构了Android的异步代码。通过Promise组件提供的多种并发模型能够更优雅的解决绝大部分的场景需求。

防踩坑指南

如果跟Activity或Fragment生命周期绑定，需要在生命周期结束时，取消掉promise的线程运行，否则可能会有内存泄露；这里可以采用AbortController来实现更优雅的中断 Promise。

并发模型

● 多任务并行请求

Promise.all()：接受任意个Promise对象，并发执行异步任务。全部任务成功，有一个失败则视为整体失败。

Promise.allSettled(): 任务优先，所有任务必须执行完毕，永远不会进入失败状态。

Promise.any()：接受任意个Promise对象，并发执行异步任务。等待其中一个成功即为成功，全部任务失败则进入错误状态，输出错误列表。

● 多任务竞速场景

Promise.race(): 接受任意个Promise对象，并发执行异步任务。时间是第一优先级，多个任务以最先返回的那个结果为准，此结果成功即为整体成功，失败则为整体失败。

扩展思考

1. Promise 最佳实践

1. 避免过长的链式调用：虽然Promise可以通过链式调用来避免回调地狱，但是如果Promise的链过长，代码的可读性和维护性也会变差。


2. 及时针对Promise进行abort操作：Promise使用不当可能会造成内存泄露，比如未调用abort，页面取消未及时销毁proimse。


3. 需要处理except异常回调，处理PromiseException.


4. 可以使用validation来实现规则校验，减少if-else的规则判断

2. Java Promise 组件实现原理

1. 状态机实现（pending、fulfilled、rejected）


2. 默认使用 ForkJoinPool 线程池，适合计算密集型任务。针对阻塞IO类型，可以使用内置ThreadPerTaskExecutor 简单线程池模型。

3. Promise vs Kotlin协程

Promise 链式调用，代码清晰，上手成本较低；底层实现仍然是线程，通过线程池管理线程调度
Koitlin 协程，更轻量的线程，使用比较灵活，可以由开发者控制，比如挂起和恢复

4. 可测试性的思考

根据 Promise 的特点，可以通过Mock状态（resolve、reject、outTime）来实现模拟成功，拒绝、超时；
实现思路：
● 自定义注解类辅助定位Hook点
● 使用ASM字节码对Promise 进行代码插桩

附录

● Promise - JavaScript | MDN

● Promises/A+

欢迎关注我的公众号，一起进步~

有一句话叫做：你看到的，不一定是真的，但可能是想让你看到的。在学习前端之前，有幸学习过一阵子PPT和Flash设计，其中有一个知识点就是，视觉效果，最常用的套路就是使用遮罩层来制作效果，今天就聊聊基于遮罩导致的前端攻击：点击劫持。

前端点击劫持

前端点击劫持实际上就是通过层叠样式，在原有的页面样式上叠加自己的内容，然后通过色彩或者透明消除用户的警惕，当用户点击看到的功能的时候，实际上点击的是隐藏的功能，这样满足攻击者的需求。比如：

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta http-equiv="X-UA-Compatible" content="IE=edge">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>前端劫持</title>

    <style>

        .myidea{

            width: 100%;

            height: 100%;

            position: absolute;

            top: 0;

            left: 0;

            opacity: 0.0;

        }

    </style>

</head>

<body>

    <div>

        视觉效果展示内容

        <img src="F:\dazejiuzhang\图片资料\yqkfdx1.jpg">

    </div>

    <div class="myidea">

        <a href="http://www.jiece.com">跳转链接</a>

    </div>

</body>

​

</html>

视觉效果

但实际上

当然，这个案例当中只是采用了一个透明的div，在实际的劫持场景当中，更多的是采用复杂的iframe来覆盖。

前端点击劫持防御

知道原理之后，防御也就需要琢磨了：

1、在自己不使用iframe的前提下，对iframe进行限制，这个可以通过HTTP头进行设置X-Frame-Options属性可以实现，X-Frame-Options有三种模式：

配置在nginx当中设置：

add_header X-Frame-Options DENY;

2、检测所有提交的内容，防止通过前端XSS攻击携带前端点击劫持内容，这个和防御XSS攻击类似。

3、通过JS限制顶级的嵌套样视：

<head>

  <style id="click_box">

    html {

      display: none !important;

    }

  </style>

</head>

<body>

  <script>

    if (self == top) {

      var style = document.getElementById('click_box')

      document.body.removeChild(style)

    } else {

      top.location = self.location

    }

  </script>

</body>

思考

前端点击劫持本身攻击成本比XSS要高一点，并且容易被防御，但是，更容易出现在大家不注意，不经意的地方，这里忽然想到之前一个大佬聊的一句话：搞安全的最后，最难的就是要搞懂人心。“关于前端点击劫持就先聊这么多，还请各位大佬多多指点。

大家好，我是老三，最近沉迷于听脱口秀，并且疯狂安利同事。

脱口秀演员常常说的一句话是：“脱口秀是冒犯的艺术”。最近我发现，同事们好像有点不一样了。

阳光灿烂的早上，趿拉着我的宝马拖鞋，跨上包浆的小黄车，屁股感受着阳光积累的炙热，往公司飞驰而去。

一步跨进电梯间，我擦汗的动作凝固住了，挂上了矜持的微笑：“老板，早上好。”

老板：“早，你还在呢？又来带薪划水了？”

我：“嗨，我这再努力，最后不也就让你给我们多换几个嫂子嘛。”

老板：“没有哈哈，我开玩笑。”

我：“我也是，哈哈哈。”

今天的电梯似乎比往常慢了很多。

我：“老板最近在忙什么？”

老板：“昨天参加了一个峰会，马xx知道吧？他就坐我前边。”

我：“卧槽，真能装。没有，哈哈。”

老板：“哈哈哈”。

电梯到了，我俩都步履匆匆地进了公司。

小组内每天早上都有一个晨会，汇报工作进度和计划。

开了一会，转着椅子，划着朋友圈的我停了下来——到我了。

我：“昨天主要……今天计划……”

Leader：“你这不能说没有一点产出，也可以说一点产出都没有。其实，我对你是有一些失望的，原本今年绩效考评给你一个……”

我：“影响你合周报了是吗？不是哈哈。”

Leader、小组同事：“哈哈哈“。

Leader：“好了，我们这次顺便来对齐一下双月OKR，你们OKR都写的太保守了，一看就是能完成的，往大里吹啊。开玩笑哈哈。”。

我：”我以前就耕一亩田，现在把整个河北平原都给犁了。不是，哈哈。”

同事：“我要带公司打上月球，把你踢下来，我来当话事人。唉，哈哈”

Leader、同事、我：“哈哈哈“。

晨会开完，开始工作，产品经理拉我和和前端对需求。

产品经理：“你们程序员懂Java语言、Python语言、Go语言，就是不懂汉语言，真不想跟你们对需求。开个玩笑，哈哈。”

我：“没啥，你吹牛皮像狼，催进度像狗，做需求像羊，就这需求文档，还没擦屁股纸字多，没啥好对的。不是哈哈。”

产品经理、前端、我：“哈哈哈”。

产品经理：“那我们就对到这了，你们接着聊技术实现。”

前端：“没啥好聊的，后端大哥看着写吧，反正你们那破接口，套的比裹脚布还厚，没事还老出BUG。没有哈哈。”

我：“还不是为了兼容你们，一点动脑子的逻辑都不写，天天切图当然不出错。不是哈哈。”

前端、我：“哈哈哈”。

经过一番拉扯之后，我终于开始写代码了。

看到一段代码，我皱起了眉头，同事写的，我顺手写下了这样一段注释：

/**

* 写这段代码的人，建议在脑袋开个口，把水倒掉。不是哈哈，开个玩笑。

**/

代码写完了，准备上线，找同事给我Review，同事看了一会，给出了评论。

又在背着我们偷偷写烂代码了，建议改行。没有哈哈。

同事、我：“哈哈哈”。

终于下班了，路过门口，HR小姐姐还在加班。

我：“小姐姐怎么还没下班？别装了，老板都走了。开玩笑哈哈。”

HR小姐姐：“这不是看看怎么优化你们嘛，任务比较重。不是，哈哈。”

HR小姐姐、我：“哈哈哈”。

我感觉到一种不一样的氛围在公司慢慢弥散开来，我不知道怎么形容，但我想到了一句话——

“既分高下，也决生死”。

写这篇的时候，想到两年前，有个叫码农小说家的作者横空出世，写了一些生动活泼、灵气十足的段子，我也跟风写了两篇，这就是“荒腔走板”系列的来源。

后来，他结婚了。

看（抄）不到的我只能自己想，想破头也写不不来像样的段子，这个系列就不了了之，今天又偶尔来了灵感，写下一篇，也顺带缅怀一下光哥带来的快乐。

节能减排，从我做起。一款Android应用如果非常耗电，是一定会被主人嫌弃的。自从Android手机的主人用了你开发的app，一天下来，也没干啥事，电就没了。那么他就会想尽办法找出耗电量杀手，当他找出后，很有可能你开发的app就被无情的卸载了。为了避免这种事情发生，我们就要想想办法让我们的应用不那么耗电，电都用在该用的时候和地方。

通过power_profile.xml查看各个手机硬件的耗电量

Google要求手机硬件生产商都要放入power_profile.xml文件到ROM里面。有些不太负责的手机生产商，就乱配，也没有真正测试过。但我们还是可以大概知道耗电的硬件都有哪些。

先从ibotpeaches.github.io/Apktool/ 下载apktool反编译工具，然后执行adb命令，将手机framework的资源apk拉取出来。

adb pull /system/framework/framework-res.apk ./

然后我们用下载好的反编译工具，将framework-res.apk进行反编译。

java -jar apktool_2.7.0.jar d framework-res.apk

apktool_2.7.0.jar换成你下载的具体的jar包名称。
power_profile.xml文件的目录如下：

framework-res/res/xml/power_profile.xml

<?xml version="1.0" encoding="utf-8"?>

<device name="Android">

    <item name="ambient.on">0.1</item>

    <item name="screen.on">0.1</item>

    <item name="screen.full">0.1</item>

    <item name="bluetooth.active">0.1</item>

    <item name="bluetooth.on">0.1</item>

    <item name="wifi.on">0.1</item>

    <item name="wifi.active">0.1</item>

    <item name="wifi.scan">0.1</item>

    <item name="audio">0.1</item>

    <item name="video">0.1</item>

    <item name="camera.flashlight">0.1</item>

    <item name="camera.avg">0.1</item>

    <item name="gps.on">0.1</item>

    <item name="radio.active">0.1</item>

    <item name="radio.scanning">0.1</item>

    <array name="radio.on">

        <value>0.2</value>

        <value>0.1</value>

    </array>

    <array name="cpu.active">

        <value>0.1</value>

    </array>

    <array name="cpu.clusters.cores">

        <value>1</value>

    </array>

    <array name="cpu.speeds.cluster0">

        <value>400000</value>

    </array>

    <array name="cpu.active.cluster0">

        <value>0.1</value>

    </array>

    <item name="cpu.idle">0.1</item>

    <array name="memory.bandwidths">

        <value>22.7</value>

    </array>

    <item name="battery.capacity">1000</item>

    <item name="wifi.controller.idle">0</item>

    <item name="wifi.controller.rx">0</item>

    <item name="wifi.controller.tx">0</item>

    <array name="wifi.controller.tx_levels" />

    <item name="wifi.controller.voltage">0</item>

    <array name="wifi.batchedscan">

        <value>.0002</value>

        <value>.002</value>

        <value>.02</value>

        <value>.2</value>

        <value>2</value>

    </array>

    <item name="modem.controller.sleep">0</item>

    <item name="modem.controller.idle">0</item>

    <item name="modem.controller.rx">0</item>

    <array name="modem.controller.tx">

        <value>0</value>

        <value>0</value>

        <value>0</value>

        <value>0</value>

        <value>0</value>

    </array>

    <item name="modem.controller.voltage">0</item>

    <array name="gps.signalqualitybased">

        <value>0</value>

        <value>0</value>

    </array>

    <item name="gps.voltage">0</item>

</device>

抓到不负责任的手机生产商一枚，好家伙，这么多0.1，明眼人一看就知道这是为了应付Google。尽管这样，我们还是可以从中知道，耗电的有Screen（屏幕亮屏）、Bluetooth（蓝牙）、Wi-Fi（无线局域网）、Audio（音频播放）、Video（视频播放）、Radio（蜂窝数据网络）、Camera的Flashlight（相机闪光灯）和GPS（全球定位系统）等。

电量杀手简介

Screen

屏幕是非常耗电的一个硬件，不要问我为什么。屏幕主要有LCD和OLED两种。LCD屏幕白色光线从屏幕背后的灯管发出，尽管屏幕显示黑屏，依旧耗电，这种屏幕逐渐被淘汰，如果你翻出个早点的功能机，或许能看到。那么大部分Android手机都是OLED的屏幕，每个像素点都是独立的发光单元，屏幕黑屏时，所有像素都不发光。有必要时，让屏幕息屏很重要，当然手机也有自动息屏的时间设置，这个不太需要我们操心。

Radio数据网络和Wi-Fi无线网络

网络也是非常耗电的，其中又以数据网络的耗电更多于Wi-Fi的耗电。所以请尽量引导用户使用Wi-Fi网络使用app的部分功能，比如下载文件。

GPS

GPS也是很耗电的硬件，所以不要动不动就请求地理位置，GPS平常是要关闭的，除非你在使用定位和导航等功能，这样你的手机续航会更好。

WakeLock

如果使用了WakeLock，是可以有效防止息屏情况下的CPU休眠，但是如果不用了，你不释放掉锁的话，则会带来很大的电量的开销。

查看手机耗电的历史记录

// 上次拔掉电源到现在的耗电情况

adb shell dumpsys batterystats --unplugged

你在逗我？让我看命令行的输出？后面我们来使用Battery Historian的图表进行分析。

使用Battery Historian分析手机耗电量

安装Docker

Docker下载网址 docs.docker.com/desktop/ins…

使用Docker容器编排

docker run -p 9999:9999 gcr.io/android-battery-historian/stable:3.0 --port 9999

获取bugreport文件

Android7.0及以上

adb bugreport bugreport.zip

Android6.0及以下

adb bugreport > bugreport.txt

上传bugreport文件进行分析

在浏览器地址栏输入http://localhost:9999

点击Browse按钮并上传bugreport.zip或bugreport.txt生成分析图表。

我们可以通过时间轴来分析应用当下的电池使用情况，比较耗电的是哪部分硬件。

使用JobScheduler来合理执行后台任务

JobScheduler是Android5.0版本推出的API，允许开发者在符合某些条件时创建执行在后台的任务。比如接通电源的情况下才执行某些耗电量大的操作，也可以把一些不紧急的任务在合适的时候批量处理，还可以避开低电量的情况下执行某些任务。

今天来跟大家讨论一下技术主管需要什么样段位的技术？

首先我要说明的一点，技术主管前提一定是技术出身。对于那些完全不懂技术，但是又身兼技术主管或者总监的同学，我这里就不再赘述，毕竟这个已经超出我目前理解力的范围。比如阿里云的王坚博士，基本上不懂技术细节，但是依然是阿里云的CTO，一手缔造了阿里云。

那我们这里再详细讨论一下，作为一名技术主管，到底应该有什么样的一个技术的段位？或者换句话来说，你的主管的技术水平需要到达什么样的一个水位？

先说结论，作为一名技术主管，一定是整个团队的技术架构师。像其他的一些大家所讨论的条件我觉得都是次要的，比如说写代码的多少，对于技术深度的钻研多少，带的团队人数多少等等，最核心的是技术主管一定要把控整个团队整个业务技术发展的骨架。

为什么说掌控团队技术架构是最重要的？因为对于一个团队来说无非就两点，第一点就是业务价值，第二点就是技术价值。

对于业务价值来说，有各种各样的同学都可以去负责业务上面的一些导向和推进，比如说产品经理，比如说运营同学。技术主管可以在一定程度上去帮助业务成功，甚至是助力业务成功，但是一定要明白技术同学一定要有自己的主轴，就是你对于整个技术的把握。因为业务上的决策说到底技术主管是只能去影响而非去决策，否则就是你们整体业务同学太过拉胯，无法形成战术合力的目的。

对于一线开发同学来说，你只要完成一个接一个的技术项目即可。但是对于技术主管来说，你就要把握整体的技术发展脉络。要清晰的明白什么样的技术架构是和当前的业务匹配的，同时又具备未来业务发展的可扩展性。

那为什么不能把整个技术架构的设计交给某一个核心的骨干研发同学呢？

所以这里就要明白，对于名技术主管来说，未必一定要深刻的钻研技术本身，一定要把技术在业务上的价值发挥到最大。所以在一定程度上来说，可以让适当的同学参与或者主导整个技术架构的设计，但是作为主管必须要了解到所谓的技术投入的产出比是什么。但是如果不对技术架构有一个彻底的理解，如何能决定ROI？

也就是在技术方案的选型里面一定要有一个平衡，能够用最小的技术投入获取到最大的技术利益，而非深究于技术本身的实习方式。如果一名技术主管不了解技术的框架或者某一些主干流程，那么就根本谈不上怎么样去评估这投入的技术产出比。一旦一名技术主管无法衡量整个技术团队的投入产出比，那就意味着整个团队的管理都是在抓虾和浑水摸鱼的状态，这时候就看你团队同学是否自觉了。

出现了这种情况下的团队，可能换一头猪在主管的位置上，业务依然运行良好。如果在业务发展好的时候，可能一直能够顺利推动，你只要坐享其成就可以了，但是一旦到了要突破困难的时期，或者在业务走下行的时候，这个时候你技术上面的优势就一点就没有了。而且在这种情况下，如果你跳槽到其他公司，作为一名技术主管，对方的公司对你的要求也是非常高的，所以这个时候你如果都说不出来你的技术价值对于业务上面的贡献是什么那想当然，你可能大概率就凉凉了。

那问题又回到了什么样的水平才能到达架构师这个话题，可以出来另一篇文章来描述，但是整体上来说，架构的本质首先一定要明白，为的就是业务的增长。

其次，架构的设计其实就是建造一个软件体系的结构，使得具备清晰度，可维护性和可扩展性。另外要想做好架构，基本的基础知识也必不可少，比如说数据库选型、分布式缓存、分库分表、幂等、分布式锁、消息架构、异步架构等等。所以本身来说做好架构师本身难度就非常大，需要长期的积累，实现厚积而薄发。如何成为一名优秀的架构师可以看我的公众号的其他文章，这里就不再详细的介绍了。

第二点是技术主管需要对于技术细节有敏感度。很多人在问一名主管到底应该具备什么样的综合能力，能不能用一种更加形象的方式来概括，我认为就有一句话就可以概括了。技术主管应该是向战略轰炸机在平常的时候一直遨游在大气的最上层能够掌控整个全局，当到了必须要战斗的时候，可以快速的补充下去，定点打击。

我参加过一次TL培训课程，讲师是阿里云智能交付技术部总经理张瑞，他说他最喜欢的一句管理概括，就是“心有猛虎，细嗅蔷薇”，也就是技术主管在平常的时候会关注于更大的宏观战略或策略，也就是注重思考全局，但是在关键的时候一定要关注和落地实际的细节。

换句更加通俗的话来说，就是管理要像战略轰炸机，平常的时候飞在万丈高空巡视，当发生了战斗的时候，立即能够实现定点轰炸。

所以如果说架构上面的设计就是对于整个团队业务和技术骨架的把握，那么对于细节的敏感度就是对于解决问题的落地能力。

那怎么样能够保证你自己有一个技术细节的敏感度？

我认为必要的代码量是需要的，也就是说对于一个主管来说，不必要写太多低代码，但一定要保证一定的代码量，让自己能够最好的，最快的，最贴近实际的理解实际的业务项目。自己写一些代码，其实好处非常多，一方面能够去巩固和加深自己对技术的理解，另外一方面也能够通过代码去更加理解业务。

当然贴近技术的方式有很多种，不一定要全部靠写代码来完成，比如说做code review的方式来完成，做技术方案的评审来完成，这都是可以的。对我来说，我就会强迫自己在每一个迭代会写上一个需求，需求会涉及到各方各面的业务点。有前端的，有后端的，也有数据库设计的。

自己亲自参与写代码或者code review，会让自己更加贴近同学，能够感知到同学的痛点，而不至于只是在空谈说教。

总结

所以对于一个技术主管来说，我认为首要的就是具备架构设计的能力，其次就是要有代码细节的敏感度，对全局和对细节都要有很强大的把控能力。

当然再总结一下，这一套理论只是适用于基础的管理者，而非高层的CTO等，毕竟不同的层级要求的能力和影响力都是不一样的。

前言

我们平时玩游戏多多少少会碰到一些视频广告，看完后是能领取游戏奖励的，然后你会发现有时候看完点击那个关闭按钮，结果是跳下载，你理所当然的认为是点击到了外边，事实真的是这样的吗？有些东西不好那啥，你们懂的，所以以下内容纯属我个人猜测，纯属虚构

1. 整个广告流程的各个角色

要想对广告这东西有个大概的了解，你得先知道你看广告的过程中都有哪些角色参与了进来。

简单来说，是有三方参与了进来：

（1）广告提供商：顾名思义负责提供广告，比如你看的广告是一款游戏的广告，那这个游戏的公司就是广告的提供商。

（2）当前应用：就是播放这个广告的应用。

（3）平台：播放广告这个操作就是平台负责的，它负责连接上面两方，从广告提供商中拿到广告，然后让当前应用接入。

平台有很多，比如字节、腾讯都有相对应的广告平台，或者一些小公司自己做广告平台。他们之间的py交易是这样的：所有广告的功能是由平台去开发，然后他会提供一套sdk或者什么的让应用接入，应用你接入之后每播放1次广告，平台就给你多少钱，但是播放的是什么广告，这个就是平台自己去下发。然后广告提供商就找到平台，和他谈商业合作，你帮我展示我家的产品的广告多少次，我给你多少钱。 简单来说他们之间的交易就是这样。

简单来说，就是广告提供商想要影响力，其它两方要钱，他们都希望广告能更多的展示。

2. 广告提供商的操作

广告提供商是花钱让平台推广广告的，那我肯定是希望尽量每次广告的展示都有用户去点击然后下载我们家的应用。

所以广告提供商想出了一个很坏的办法，相信大家都遇到过，就是我播放视频，我在视频的最后几帧里面的图片的右上角放一个关闭图片，误导用户这个关闭图片是点了之后能关闭的，其实它是视频的一部分，所以你点了就相当于点了视频，那就触发跳转下载应用这些操作。

破解的方法也很简单，你等到计算结束后的几秒再点关闭按钮，不要一看到关闭按钮的图片出来马上点。

3. 应用的操作

应用是很难在广告播放的时候去做手脚，因为这部分的代码不是他们写的，他们只是去调用平台写的代码。

那他们想让广告尽可能多的展示，唯一能做的就是把展示广告的地方增加，尽可能多的让更多场景能展示广告。当然这也有副作用，你要是这个应用点哪里都是广告，这不得把用户给搞吐了，砸了自己的口碑，如果只有一些地方有，用户还是能理解的，毕竟赚钱嘛，不寒参。

4. 平台的操作

平台的操作那就丰富了，代码是我写的，兄弟，我想怎么玩就怎么玩，我能有一百种方法算计你。

猜测的，注意，是猜测的[狗头]

有的人说，故意把关闭按钮设置小，让我们误触关闭按钮以外的区域。我只能说，你让我来做，我都不屑于把关闭按钮设置小。

我们都知道平时开发时，我们觉得点击按钮不灵，所以我们想扩大图标的点击区域，但是又不想改变图标的大小，所以我们用padding来实现。同样的，我也能做到不改变图标的大小，然后缩小点击的范围

我写一个自定义view（假设就是关闭图标）

public class TestV extends View {



    public TestV(Context context) {

        super(context);

    }



    public TestV(Context context, AttributeSet attrs) {

        super(context, attrs);

    }



    public TestV(Context context, AttributeSet attrs, int defStyleAttr) {

        super(context, attrs, defStyleAttr);

    }



    @Override

    public boolean dispatchTouchEvent(MotionEvent event) {

        if (event.getAction() == MotionEvent.ACTION_DOWN) {

            int w = getMeasuredWidth();

            int h = getMeasuredHeight();

            Log.d("mmp", "============ view点击");

            if (event.getX() < w / 4 || event.getX() > 3 * w / 4 || event.getY() < h / 4 || event.getY() > 3 * h / 4) {

                return super.dispatchTouchEvent(event);

            } else {

                Log.d("mmp", "============ view点击触发-》关闭");

                return true;

            }

        }

        return super.dispatchTouchEvent(event);

    }

}

代码很简单就不过多讲解，能看出我很简单就实现让点击范围缩小1/4。所以当你点到边缘的时候，其实就相当于点到了广告。

除了缩小范围之外，我还能设置2秒前后点击是不同的效果，你有没有一种感觉，第一次点关闭按钮就是跳到下载应用，然后返回再点击就是关闭，所以你觉得是你第一次点击的时候是误触了外边。

public class TestV extends View {



    private boolean canClose = true;



    public TestV(Context context) {

        super(context);

    }



    public TestV(Context context, AttributeSet attrs) {

        super(context, attrs);

    }



    public TestV(Context context, AttributeSet attrs, int defStyleAttr) {

        super(context, attrs, defStyleAttr);

    }



    @Override

    public void setVisibility(int visibility) {

        super.setVisibility(visibility);

        if (visibility == View.VISIBLE) {

            canClose = false;

        }

    }



    @Override

    public boolean dispatchTouchEvent(MotionEvent event) {

        if (event.getAction() == MotionEvent.ACTION_DOWN) {

            int w = getMeasuredWidth();

            int h = getMeasuredHeight();

            Log.d("mmp", "============ view点击");

            if (!canClose) {

                return super.dispatchTouchEvent(event);

            } else {

                Log.d("mmp", "============ view点击触发-》关闭");

                return true;

            }

        }

        return super.dispatchTouchEvent(event);

    }



    // 播放完成

    public void playFinish() {

        setVisibility(VISIBLE);

        Handler handler = new Handler(Looper.getMainLooper());

        handler.postDelayed(new Runnable() {

            @Override

            public void run() {

                canClose = true;

            }

        }, 2000);

    }



}

播放完成之后调用playFinish方法，然后会把canClose这个状态设置为false，2秒后再设为true。这样你在2秒前点击按钮，其实就是点击外部的效果，也就会跳去下载。

而且你注意，这些限制，我可以不写死在代码里面，可以用后台返回，比如这个2000,我可以后台返回。我就能做到比如第一天我返回0,你觉得没什么问题，能正常点关闭，我判断你是第二天，我直接返2000给你,然后你一想，之前都是正常的，那这次不正常，肯定是我点错。

你以为的意外只不过是我想让你以为是意外罢了。那这个如何去破解呢？我只能说无解，他能有100种方法让你点中跳出去下载，那还能有是什么解法?

即刻点赞展示

点赞的数字增加和减少并不是整个替换，而是差异化替换。再加上动画效果就看的很舒服。

自己如何实现这种数字切换呢？

下面用一张图来展示我的思路：

现在只需要根据这张图，写出对应的动画即可。
分为2种场景：

• 数字+1：
  
  
  
  • 差异化的数字从3号区域由渐变动画（透明度 0- 255） + 偏移动画 （3号区域绘制文字的基线，2号区域绘制文字的基线），将数字移动到2号位置处
  
  
  • 差异化的数字从2号区域由渐变动画（透明度 255- 0） + 偏移动画（2号区域绘制文字的基线，1号区域绘制文字的基线），将数字移动到1号位置处
  
  
  
  


• 数字-1
  
  
  
  • 差异化的数字从1号区域由渐变动画（透明度 0- 255） + 偏移动画 （1号区域绘制文字的基线，2号区域绘制文字的基线），将数字移动到2号位置处
  
  
  • 差异化的数字从2号区域由渐变动画（透明度 255- 0） + 偏移动画（2号区域绘制文字的基线，3号区域绘制文字的基线），将数字移动到3号位置处
  
  
  
  

公共部分就是：
不变的文字不需要做任何处理，绘制在2号区域就行。绘制差异化文字时，需要加上不变的文字的宽度就行。

效果展示

源码

class LikeView @JvmOverloads constructor(

    context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0

) : View(context, attrs, defStyleAttr) {



    private val paint = Paint().also {

        it.isAntiAlias = true

        it.textSize = 200f

    }



    private val textRect0 = Rect(300, 100, 800, 300)

    private val textRect1 = Rect(300, 300, 800, 500)

    private val textRect2 = Rect(300, 500, 800, 700)



    private var nextNumberAlpha: Int = 0

        set(value) {

            field = value

            invalidate()

        }



    private var currentNumberAlpha: Int = 255

        set(value) {

            field = value

            invalidate()

        }



    private var offsetPercent = 0f

        set(value) {

            field = value

            invalidate()

        }



    private val fontMetrics: FontMetrics = paint.fontMetrics

    private var currentNumber = 99

    private var nextNumber = 0

    private var motionLess = currentNumber.toString()

    private var currentMotion = ""

    private var nextMotion = ""



    private val animator: ObjectAnimator by lazy {

        val nextNumberAlphaAnimator = PropertyValuesHolder.ofInt("nextNumberAlpha", 0, 255)

        val offsetPercentAnimator = PropertyValuesHolder.ofFloat("offsetPercent", 0f, 1f)

        val currentNumberAlphaAnimator = PropertyValuesHolder.ofInt("currentNumberAlpha", 255, 0)

        val animator = ObjectAnimator.ofPropertyValuesHolder(

            this,

            nextNumberAlphaAnimator,

            offsetPercentAnimator,

            currentNumberAlphaAnimator

        )

        animator.duration = 200

        animator.interpolator = DecelerateInterpolator()

        animator.addListener(

            onEnd = {

                currentNumber = nextNumber

            }

        )

        animator

    }



    override fun onDraw(canvas: Canvas) {

        paint.alpha = 255



        paint.color = Color.LTGRAY

        canvas.drawRect(textRect0, paint)



        paint.color = Color.RED

        canvas.drawRect(textRect1, paint)



        paint.color = Color.GREEN

        canvas.drawRect(textRect2, paint)



        paint.color = Color.BLACK

        if (motionLess.isNotEmpty()) {

            drawText(canvas, motionLess, textRect1, 0f)

        }



        if (nextMotion.isEmpty() || currentMotion.isEmpty()) {

            return

        }



        val textHorizontalOffset =

            if (motionLess.isNotEmpty()) paint.measureText(motionLess) else 0f

        if (nextNumber > currentNumber) {

            paint.alpha = currentNumberAlpha

            drawText(canvas, currentMotion, textRect1, textHorizontalOffset, -offsetPercent)

            paint.alpha = nextNumberAlpha

            drawText(canvas, nextMotion, textRect2, textHorizontalOffset, -offsetPercent)

        } else {

            paint.alpha = nextNumberAlpha

            drawText(canvas, nextMotion, textRect0, textHorizontalOffset, offsetPercent)

            paint.alpha = currentNumberAlpha

            drawText(canvas, currentMotion, textRect1, textHorizontalOffset, offsetPercent)

        }

    }



    private fun drawText(

        canvas: Canvas,

        text: String,

        rect: Rect,

        textHorizontalOffset: Float = 0f,

        offsetPercent: Float = 0f

    ) {

        canvas.drawText(

            text,

            rect.left.toFloat() + textHorizontalOffset,

            rect.top + (rect.bottom - rect.top) / 2f - (fontMetrics.bottom + fontMetrics.top) / 2f + offsetPercent * 200,

            paint

        )

    }





    override fun onDetachedFromWindow() {

        super.onDetachedFromWindow()

        animator.end()

    }



    fun plus() {

        if (currentNumber == Int.MAX_VALUE) {

            return

        }

        nextNumber = currentNumber + 1



        processText(findEqualsStringIndex())



        if (animator.isRunning) {

            return

        }

        animator.start()

    }



    fun minus() {

        if (currentNumber == 0) {

            return

        }

        nextNumber = currentNumber - 1

        processText(findEqualsStringIndex())

        if (animator.isRunning) {

            return

        }

        animator.start()

    }



    private fun findEqualsStringIndex(): Int {

        var equalIndex = -1

        val nextNumberStr = nextNumber.toString()

        val currentNumberStr = currentNumber.toString()



        val endIndex = min(currentNumberStr.length, nextNumberStr.length) - 1



        for (index in 0..endIndex) {

            if (nextNumberStr[index] != currentNumberStr[index]) {

                break

            }

            equalIndex = index

        }

        return equalIndex

    }



    private fun processText(index: Int) {

        val currentNumberStr = currentNumber.toString()

        val nextNumberStr = nextNumber.toString()

        if (index == -1) {

            motionLess = ""

            currentMotion = currentNumberStr

            nextMotion = nextNumberStr

        } else {

            motionLess = currentNumberStr.substring(0, index + 1)

            currentMotion = currentNumberStr.substring(index + 1)

            nextMotion = nextNumberStr.substring(index + 1)

        }

    }

}

遇到的痛点

这篇文章或许有另一个不太优雅的名字--“屎山治理”。

在繁重的业务开发当中，我们会面临一些问题。伴随着项目的不断发展，项目出现代码冗余，存在大片没用代码的情况。

举个栗子，重构优化后，某位同学没有删除掉冗余代码，项目残留着废弃的没用文件，导致跨文件引用混乱。还有，业务变更所导致逻辑代码的废弃，项目中重复的定义代码，这些情况在一个长期的项目发展的阶段里面会造成逻辑混乱，重复定义，二义性等等。

其实，程序员都是写代码的，但是很少人敢删代码，久而久之，也就没人敢动废弃代码了。

虽然在项目构建工具的加持下，tree-shaking能够控制项目的包产物体积，但是从开发体验（DX）的角度出发，这往往都是一些心智负担。结合我自己的一些优化经验，简单分享一下：

优化手段

手段一：eslint的unused检查

首先我们应该考虑的是，通过 eslint 的规则有效的去规避一些项目当中已有的没用的变量和方法，这样保证单文件代码的可用性，我们可以很容易的发现哪个import或者variable没有被使用。import的冗余控制也能够有效控制打包的范围，减少包体积。

eslint最常用的就是官方的no-unused-vars这一条规则。

当然还有一些，第三方的unused-exports规则，例如eslint-plugin-canonical的no-unused-exports或者eslint-plugin-unused-imports，这种大家可以适度采用，毕竟eslint是把“双刃剑”。

手段二：静态代码工具扫描

通过一些静态分析工具可以有效地分析代码语法，根据语法树信息来判断内容是有用还是没用。

ts-unused-exports是一个很成熟的分析工具，它可以通过 ts-compiler 对 typescript代码语法进行分析，(tsconfig可以配置allowjs，分析javascript语法)，通过TS语法树有效地找到语法中没用的 export。

该工具能够把所有的没用的 export 找到。这时候我们会很自然地想到一个问题，能否找到完全没有使用的废弃文件。这里分两种情况，情况一，该文件所有的 export 都已经被废弃了，这种情况出现在代码重构的情况，另外一种情况是部分的export没有被使用，那这种需要case by case的判断，到底这个代码有没有存在意义？

暂时这个工具只能找到所有的 export 函数，并没有文件粒度，并不能满足我们的“诉求”。我们希望能把完全没用的文件直接删除掉，所以我提了一个issue。

我查看了源码，parse过后，会通过getExportMap获取每个文件，且它的所有exports内容。我写了一个PR，在和作者沟通交流下，尽量以最小的 api 改动情况来处理。利用一个参数findCompletelyUnusedFiles来控制是否找出完全没有被使用的文件，参考PR#254。

改动涉及最核心内容，如下。将该文件的真实所有 export 和 unused export 作对比，以此判断它是完全没用的文件。

const realExportNames = Object.keys(exports);



if (

  extraOptions?.findCompletelyUnusedFiles &&

  isEqual(realExportNames, unusedExports)

) {

  unusedFiles.push(path);

}

});

当我们得到了这个结果后，我们可以通过自己编写的脚本“大胆”的删除文件了。

在删除脚本内，我们要想清楚几个事情：

1. 有范围的扫描（避免错删，所有改动在可控的范围内）


2. 后缀名白名单（多市场的代码可能会存在“多态”，例如，id代表印尼，index.id.ts它不应该被清除掉）

const result = analyzeTsConfig('./tsconfig.json', ['--findCompletelyUnusedFiles']);



const outputPattern = ['/pages/partner/', '/pages/store/', '/pages/staff/', '/services/'];

const excludePattern = ['.id.', '.my.', '.ph.', '.sg.', '.vn.', '.th.', '.br.'];



function filterOutput(name: string) {

  for (let index = 0; index < outputPattern.length; index++) {

    if (name.includes(outputPattern[index]) ) {

      return true;

    }

  }

  return false;

}



function filterExclude(name: string) {

  for (let index = 0; index < excludePattern.length; index++) {

    if (name.includes(excludePattern[index]) ) {

      return false;

    }

  }

  return true;

}



const { unusedFiles, ...rest } = result;



Object.keys(rest)

.filter(r => filterOutput(r))

.filter(r => filterExclude(r))

.map((key) => {

  const exportNames = rest[key].map(r=> r.exportName).join(',')

  console.log(chalk.green(key) + ' ' + exportNames);

}) 



if(result.unusedFiles) {

  console.log('no used files: ');

  result.unusedFiles

  .filter(r => filterOutput(r))

  .filter(r => filterExclude(r))

  .forEach((r) => {

    fs.unlinkSync(r);

  })

}

手段三：人工调整已有代码的合理性

在删除完代码后，项目中 ts-unused-export 还会扫描出一些部分 export 废弃的文件，我们只能按照自身的情况做出调整。每个团队的代码分层情况有所不同。这些文件可能不需要改动，也可能是需要调整该纯函数位置。我们应该把它们放在合理的位置。

总结

首先“清除废弃代码”是一个低频操作。可能我们一年或者几年，清理一次即可，保证代码的“清爽”。所以放在 webpack 等构建工具执行反而不太合适，脚本偶尔扫描，把一些废弃代码清干净，你的DX（developing experience）又回来了。

当然你忍受能力很强也可以“不做”。这篇文章适合具有轻度“代码强迫症”的同学食用。

PS：加餐，也可以参考knip，功能更强大噢。

前言

大家好，我是林三心，用最通俗易懂的话讲最难的知识点是我的座右铭，基础是进阶的前提是我的初心~

背景

最近我们公司有一个页面，这个页面其实结构很简单，就是三个列表同时出现在某个项目的首页里，大概页面是这样的，差不多每一个列表都有100-1000条数据吧~数据量也不算多，三个列表顶天就3000条数据，并且数据也不复杂，所以也没做什么处理

开发阶段没发现什么问题，但是上了生产后，问题来了，很多“用户”反馈说这个首屏加载超级慢，这个项目是公司内部使用的，“用户”都是公司内部某个部门的员工们，由于他们的公司电脑配置比较差，所以这点数据量就足够他们电脑吃不消了，所以导致了首屏加载会非常慢~~有多慢呢？最慢的居然达到 8s。。。

• Scripting： JavaScript逻辑处理时间


• Rendering： UI渲染时间

有人会问，不应该是数据量多导致渲染慢吗？那为啥主要耗时都在 Scripting 呢？

那是因为 Vue3 在渲染前会进行一系列的 JavaScript 逻辑处理，包括：

• 1、数据创建


• 2、模板解析


• 3、虚拟DOM创建


• 4、虚拟DOM转真实DOM

不过最耗时的肯定就是后两步了，所以需要针对这个问题，做一个解决方案

页面代码先贴一下

懒加载分页？虚拟滚动？不行！

很多人第一想象到的解决方案就是做分页，或者做懒加载，其实分页和懒加载都是一个道理，就是按需去加载数据，但是不好意思，后端接口是老接口并且没有做分页，团队不想要耗费后端精力去重构这个接口，所以这条路就别想啦！！！

又有人说虚拟滚动，我这么说吧，虚拟滚动用在性能好的电脑上效果是很不错的，如果用在性能差的电脑上，那么效果会非常糟糕，毫无疑问虚拟滚动确实会减少首屏加载的时间，但是性能差的电脑滚动快了，会有白屏现象，而且很严重，熟悉虚拟滚动的人都知道，虚拟滚动是根据滚动时间去重新计算渲染区域的，这个计算时需要时间的，但是用户滚动是很快的，性能差的电脑根本计算不过来所以导致会有短暂白屏现象。。

又有人说虚拟滚动不是可以做预加载吗？可以解决短暂白屏现象。还是那句话，在性能好的电脑上确实可以，但是性能差的电脑上，你预渲染再多也没用，该白屏还是得白屏

分片渲染

不能做分页，不能做懒加载，不能做虚拟滚动，那么咋办呢？我还是选择了分片渲染来进行渲染，也就是在浏览器渲染的每一帧中去不断渲染列表数据，一直到渲染出整个列表数据为止。

这样做就能保证首屏时不会一股脑把整个列表都渲染出来了，而是先进首页后，再慢慢把所有列表都渲染完成

实施

要怎么才能保证在每一个帧中去控制列表渲染呢？可以使用requestAnimationFrame，我们先封装一个useDefer

• frame： 记录当前的帧数


• checkIsRender： 拿列表每一项的索引去跟当前帧数比较，到达了指定索引帧数才渲染这一项

页面里直接使用这个 hooks 即可

这样就能保证了达到一定帧数时，才去渲染一定的列表数据，我们来看看效果，可以看到首屏快了很多，从8s -> 2s，因为首屏并不会一股脑加载所有数据，而是逐步加载，这一点看滚动条的变化就知道了~

滚动条一直在变，因为数据在不断逐步渲染

已经尽力了，实在不行这边劝你还是换电脑吧~

优化点

我们在完成一个功能后，可以看出这个功能有什么

• 列表渲染完毕后，可以停止当前帧的计算


• 现在是一帧渲染一条数据，能否控制一帧渲染的多条数据？

自定义view实战(12)：安卓粒子线条效果

前言

很久没写代码了，忙工作、忙朋友、人也懒了，最近重新调整自己，对技术还是要有热情，要热情的话还是用自定义view做游戏有趣，写完这个粒子线条后面我会更新几个小游戏博文及代码，希望读者喜欢。

这个粒子效果的控件是去年写的，写的很差劲，这几天又重构了一下，还是难看的要命，勉强记录下吧。

需求

主要就是看到博客园的粒子线条背景很有意思，就想模仿一下。核心思想如下：

• 1、随机出现点


• 2、范围内的点连线


• 3、手指按下，加入点，范围内点向手指移动

效果图

效果图就是难看，没得说。

代码

import android.annotation.SuppressLint

import android.content.Context

import android.graphics.Canvas

import android.graphics.Color

import android.graphics.Paint

import android.os.Handler

import android.os.Looper

import android.os.Message

import android.util.AttributeSet

import android.view.MotionEvent

import android.view.View

import java.lang.ref.WeakReference

import kotlin.math.pow

import kotlin.math.sqrt



/**

 * 模仿博客粒子线条的view

 *

 * 核心思想简易版

 *

 * 1、随机出现点

 * 2、范围内的点连线

 * 3、手指按下，加入点，范围内点向手指移动

 *

 * @author silence

 * @date 2022-11-09

 *

 */

class ParticleLinesBgView @JvmOverloads constructor(

    context: Context,

    attributeSet: AttributeSet? = null,

    defStyleAttr: Int = 0

): View(context, attributeSet, defStyleAttr){



    companion object{

        // 屏幕刷新时间，每秒20次

        const val SCREEN_FLUSH_TIME = 50L



        // 新增点的间隔时间

        const val POINT_ADD_TIME = 200L



        // 粒子存活时间

        const val POINT_ALIVE_TIME = 18000L



        // 吸引的合适距离

        const val ATTRACT_LENGTH = 250f



        // 维持的合适距离

        const val PROPER_LENGTH = 150f



        // 粒子被吸引每次接近的距离

        const val POINT_MOVE_LENGTH = 30f



        // 距离计算公式

        fun getDistance(x1: Float, y1: Float, x2: Float, y2: Float): Float {

            return sqrt(((x1 - x2).toDouble().pow(2.0)

                    + (y1 - y2).toDouble().pow(2.0)).toFloat())

        }

    }



    // 存放的粒子

    private val mParticles = ArrayList<Particle>(64)



    // 手指按下位置

    private var mTouchParticle: Particle? = null



    // 处理的handler

    private val mHandler = ParticleHandler(this)



    // 画笔

    private val mPaint = Paint().apply {

        color = Color.LTGRAY

        strokeWidth = 3f

        style = Paint.Style.STROKE

        flags = Paint.ANTI_ALIAS_FLAG

    }



    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {

        super.onSizeChanged(w, h, oldw, oldh)

        // 通过发送消息给handler实现间隔添加点

        mHandler.removeMessages(0)

        mHandler.sendEmptyMessageDelayed(0, POINT_ADD_TIME)

    }



    override fun onDraw(canvas: Canvas) {

        super.onDraw(canvas)

        // 绘制点和线

        for (i in 0 until mParticles.size) {

            val point = mParticles[i]

            canvas.drawPoint(point.x, point.y, mPaint)

            // 连线

            for (j in (i + 1) until mParticles.size) {

                val another = mParticles[j]

                val distance = getDistance(point.x, point.y, another.x, another.y)

                if (distance <= PROPER_LENGTH) {

                    canvas.drawLine(point.x, point.y, another.x, another.y, mPaint)

                }

            }

        }



        mTouchParticle?.let {

            // 手指按下点与附近连线

            for(point in mParticles) {

                val distance = getDistance(point.x, point.y, it.x, it.y)

                if (distance <= PROPER_LENGTH) {

                    canvas.drawLine(point.x, point.y, it.x, it.y, mPaint)

                }

            }



            // 吸引范围显示

            mPaint.color = Color.BLUE

            canvas.drawCircle(it.x, it.y, PROPER_LENGTH, mPaint)

            mPaint.color = Color.LTGRAY

        }

    }





    @SuppressLint("ClickableViewAccessibility")

    override fun onTouchEvent(event: MotionEvent): Boolean {

        when(event.action) {

            MotionEvent.ACTION_DOWN -> {

                mTouchParticle = Particle(event.x, event.y, 0)

            }

            MotionEvent.ACTION_MOVE -> {

                mTouchParticle!!.x = event.x

                mTouchParticle!!.y = event.y

                invalidate()

            }

            MotionEvent.ACTION_UP -> {

                mTouchParticle = null

            }

        }

        return true

    }



    // 粒子

    class Particle(var x: Float, var y: Float, var counter: Int)



    // kotlin自动编译为Java静态类，控件引用使用弱引用

    class ParticleHandler(view: ParticleLinesBgView): Handler(Looper.getMainLooper()){

        // 控件引用

        private val mRef: WeakReference<ParticleLinesBgView> = WeakReference(view)

        // 粒子出现控制

        private var mPointCounter = 0



        override fun handleMessage(msg: Message) {

            mRef.get()?.let {view->

                // 新增点

                mPointCounter++

                if (mPointCounter == (POINT_ADD_TIME / SCREEN_FLUSH_TIME).toInt()) {

                    // 随机位置

                    val x = (Math.random() * view.width).toFloat()

                    val y = (Math.random() * view.height).toFloat()

                    view.mParticles.add(Particle(x, y, 0))

                    mPointCounter = 0

                }



                val iterator = view.mParticles.iterator()

                while (iterator.hasNext()) {

                    val point = iterator.next()



                    // 移除失活粒子

                    if (point.counter == (POINT_ALIVE_TIME / SCREEN_FLUSH_TIME).toInt()) {

                        iterator.remove()

                    }



                    // 手指按下时，粒子朝合适的距离移动

                    view.mTouchParticle?.let {

                        val distance = getDistance(point.x, point.y, it.x, it.y)

                        if(distance in PROPER_LENGTH..ATTRACT_LENGTH) {

                            // 横向接近

                            if (point.x < it.x) point.x += POINT_MOVE_LENGTH

                            else point.x -= POINT_MOVE_LENGTH

                            // 纵向接近

                            if (point.y < it.y) point.y += POINT_MOVE_LENGTH

                            else point.y -= POINT_MOVE_LENGTH

                        }else if(distance <= PROPER_LENGTH) {

                            // 横向远离

                            if (point.x < it.x) point.x -= POINT_MOVE_LENGTH

                            else point.x += POINT_MOVE_LENGTH

                            // 纵向远离

                            if (point.y < it.y) point.y -= POINT_MOVE_LENGTH

                            else point.y += POINT_MOVE_LENGTH

                        }

                    }

                }



                // 循环发送

                view.invalidate()

                view.mHandler.sendEmptyMessageDelayed(0, POINT_ADD_TIME)

            }

        }

    }

}

这里没写onMeasure，注意下不能用wrap-content，布局的话改个黑色背景就行了。

主要问题

下面简单讲讲吧。

粒子

这里用了个数据类构造了粒子，用了一个ArrayList来存放，本来想用linkedHashMap来保存并实现下LRU的，结果连线的时候比较复杂，重构的时候直接删了，后面用了一个counter来控制粒子的存活时间。

逻辑控制

一开始的时候想的比较复杂，实现来弄得自己头疼，后面觉得何不将逻辑和绘制分离，在ondraw里面只进行绘制不就行了，逻辑通过handler来更新，实际这样在我看来是对的。

我这用了一个Handler配合嵌套循环发送空消息，实现定时更新效果，每隔一段时间更新一下逻辑，Handler内部通过弱引用获得view，并对其中的内容修改，修改完成后，通过invalidate出发线程更新。

新增点

Handler会定时更新，只需要在handleMessage里面添加点就行了，为了控制点出现的频率，我这又引入了控制变量。

粒子生命周期

handleMessage里面会检查粒子是否失活，失活了就通过iterator去移除，移除数组内内容还是尽量通过iterator去实现吧，特别是for-eacn循环以及for循环内删除多个时，会出错的！

粒子趋向于手指

手指按下时设置mTouchParticle，移动时更新这个mTouchParticle，手指抬起时对mTouchParticle赋空，这样在handleMessage里面只要在mTouchParticle不为空时稍稍改变下其他粒子的位置，就可以达到趋向效果。

粒子连线

这里我没有想到什么好办法，就是暴力破解，直接两两计算，并对合适距离的粒子进行连线。

1.这篇文章写什么？

在工作中碰到了这样一个需求，要从数据库里面读取一段时间内，每天某些时刻对应的温度数据，一天可能会设置有多个时间点，导出到excel中的模板需要支持多种格式的，比如一个月，一个季度，上半年，下半年等，并且需要支持灵活的配置导出的时间段范围。超过温度的点需要用红色来进行标识

2.为什么写这篇文章

在工作中碰到了需要导出excel报表的需求，写这篇文章记录从需求到实现的过程，供后续参考和改进

3.如何实现？

要实现导出excel，首先就想到了easyexcel，它可以支持读、写、填充excel，针对现在这个需求，如果需要自定义时间的话可以通过配置字典，前端读取字典用dayjs来进行解析，把解析到的时间范围给到后端，后端再根据时间范围去导出数据，至于excel方面，想到了先用占位符在excel模板中预设好位置，然后用代码进行填充，主要的实现流程就大概有了

4.具体实现

根据上面的主要流程，下面就来进行每一步的细化，首先是前端

4.1 解析时间

通过字典来读取时间范围的代码，至于为什么不用后端来实现，之前也考虑过，不过因为无法确定具体的时间，就没用后端去实现，因为一个月不固定有多少天，不固定有多少周，如果用后端去实现的话可能会得不到准确的时间，反观前端的dayjs，就可以很简单的实现这个功能，通过解析dayjs代码来实现时间的获取，代码如下：

<template>

  <div>

    {{getDates()}}

  </div>

</template>



<script lang="ts" setup>

import dayjs from "dayjs";

const getDates = () =>{

  const str =  "const startTime = dayjs().startOf('year').format('YYYY-MM-DD HH:mm:ss');const endTime = dayjs().endOf('year').format('YYYY-MM-DD HH:mm:ss');return [startTime, endTime]"

  const timeFunc = new Function('dayjs', str);

  const data =  timeFunc(dayjs)

  console.log(data[0])

  console.log(data[1])

  return timeFunc(dayjs)

}

</script>

用str来模拟从字段中读取到的时间范围代码，用dayjs解析出来，这样页面上就会直接打印出当前的时间：
[ "2023-01-01 00:00:00", "2023-12-31 23:59:59" ]

到此，前端解析时间的任务就完成了

4.2 导出excel

万丈高台起于垒土，要实现本次需求，首先要能导出excel，然后再考虑样式，最后再考虑现有可行方案的兼容性，能否兼容多种格式的模板。经过考察官网，发现了两种看起来比较可行和符合目前需求的导出方式：
首先把依赖导入先：

<dependency>  

    <groupId>com.alibaba</groupId>  

    <artifactId>easyexcel</artifactId>  

    <version>3.2.1</version>  

</dependency>

方式1: 定义一个模板，里面就搞几个占位符，每个占位符替换一个内容

直接上代码：

@Test

public void simpleFill() {

    // 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替

    String templateFileName = "F:/excel/" + "simple.xlsx";

    // 方案1 根据对象填充

    String fileName = "F:/excel/" + System.currentTimeMillis() + ".xlsx";

    // 这里会填充到第一个sheet， 然后文件流会自动关闭

    Map<String, Object> map = new HashMap<>();

    map.put("name", "张三");

    map.put("number", 5.2);

    map.put("month", 5);

    EasyExcel.write(fileName).withTemplate(templateFileName)

            .sheet().doFill(map);

}

看效果，替换成功了，能正常替换，这种方式能跑：

方式2 定义一个模板，里面搞几个占位符，以.开头的为循环的占位符

直接上代码：

    @Test

    public void horizontalFill() {

        String templateFileName = "F:/excel/" + "simpleHeng.xlsx";

        String fileName = "F:/excel/" + System.currentTimeMillis() + "heng" + ".xlsx";

        // 方案1

        try (ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName)

                .build()) {

            WriteSheet writeSheet = EasyExcel.writerSheet().build();

            excelWriter.write(data(),writeSheet);

        }

    }

private List<FillData> data() {

    List<FillData> list = ListUtils.newArrayList();

    for (int i = 0; i < 10; i++) {

        FillData fillData = new FillData();

        list.add(fillData);

        fillData.setName("张三" + i);

        fillData.setNumber(5.2);

        fillData.setDate(new Date());

    }

    return list;

}

@Getter

@Setter

@EqualsAndHashCode

public class FillData {

    private String name;

    private double number;

    private Date date;

}

看效果，替换成功(虽然哪里感觉不对劲)：

现在基本的替换模板实现了，那么就进一步深入，给表格里面的内容添加颜色样式

经过网上搜索了一下，发现自定义样式需要写一个类去实现CellWriteHandler，从而自定义样式

@Slf4j

public class CustomCellWriteHandler implements CellWriteHandler {



    @Override

    public void afterCellDispose(CellWriteHandlerContext context) {

        Cell cell = context.getCell();

        Workbook workbook = context.getWriteWorkbookHolder().getWorkbook();

        CellStyle cellStyle = workbook.createCellStyle();

        Font writeFont = workbook.createFont();

        writeFont.setColor(IndexedColors.RED.getIndex());

        writeFont.setBold(true);

        cellStyle.setFont(writeFont);

        cell.setCellStyle(cellStyle);

        context.getFirstCellData().setWriteCellStyle(null);

    }

}

然后在原有导出代码的基础上加个registerWriteHandler(new CustomCellWriteHandler())

EasyExcel.write(fileName).withTemplate(templateFileName)

        .registerWriteHandler(new CustomCellWriteHandler())

        .sheet().doFill(map);

然后就可以看到导出的效果了

再试试第二种方式，也就是循环写入的，加个样式：

WriteSheet writeSheet = EasyExcel.writerSheet().registerWriteHandler(new CustomCellWriteHandler()).build();

然后导出，发现这种方式的导出的excel未能成功设置颜色，后面也尝试了很多次，确定了这种方式没法带上样式，所以就放弃这种方式了

到这里就只剩下excel中每个位置的都用一个占位符来占位替换的方式了

4.3 实现思路

确定了可行的实现方式，现在就要在这种方式上思考如何实现兼容多种时间段，多种模板的导出。需求中每天可能会设置若干个点，也可能需要导出不同时间段的温度数据，例如月、季度、半年等，或者是其他更细的时间点，每次的模板可能也不大一样，例如下面的几种：

老王的模板

老张的模板

老李的模板

可以看出需要兼容不同的模板确实是个伤脑筋的事情，后面发现了个比较折中的办法：因为目前能实现excel上导出带样式的就只有替换占位符的方法，如何在不改代码的前提下适配多种模板呢，就直接把模板上每个格子都对应一个占位符，只要后端每次都是按照固定规则去生成数据的，那么只要设置好模板里每个格子的占位符就可以解决问题了。只要每次生成数据的顺序都是按照{t1}、{t2}、{t3}这样，依次类推下去，只要模板配置好占位符即可。例如每天一个监测点，那{t1}就对应第一天监测点的温度，{t2}就对应第二天监测点的温度，如果每天两个监测点，那么{t1}和{t2}就分别对应第一天的第一、第二个监测点的温度。这样就可以实现导出月、季度、半年的数据而不用改代码了，如果要导出某个时间段的，例如1月15日到2月15日的，这种时间段的话就使用大一级的模板，使用季度的模板即可兼容。

4.4 代码实现

有了上面的思路，大致实现流程就出来了

4.4.1 前端解析字符串，获取时间范围

这个上面有提及，这里就不再赘述，跳过

4.4.2 后端获取每天配置的时间点

由于配置的时间点是12、13、15这种，并不是具体的一个时间，因此需要结合时间范围来解析成具体的时间，首先需要获取时间段里面的每一天，然后再根据配置的时间点得到每个具体的时间点，获取到了时间点之后就可以去数据库中查询这个时间点对应的数据，模拟代码如下：
首先说明，这里引入了hutool来处理时间

<dependency>  

    <groupId>cn.hutool</groupId>  

    <artifactId>hutool-all</artifactId>  

    <version>5.8.18</version>  

</dependency>

public static void main(String[] args) {

        DateTime startTime = DateUtil.parse("2023-07-01 00:00:00");

        DateTime endTime = DateUtil.parse("2023-10-31 23:59:59");

        List<Date> timeRangeDates = getTimeRangeDates(startTime, endTime);

        List<String> times = Arrays.asList("12");

        Map<DateTime, Float> resultMap = getTemperature(timeRangeDates, times);

    }



    /**

     * 获取要导出数据的Map, key为时间,value为时间对应的值

     *

     * @param timeRangeDates 时间范围

     * @param times          每天定义的时间点

     * @return 导出的map

     */

    private static Map<DateTime, Float> getTemperature(List<Date> timeRangeDates, List<String> times) {

        Map<DateTime, Float> resultMap = new HashMap<>();

        for (Date timeRangeDate : timeRangeDates) {

            for (String time : times) {

                // eg: 12 ==> 2023-11-07 12:00:00

                String tempTime = DateUtil.formatDateTime(timeRangeDate).substring(0, 11) + time + ":00:00";

                DateTime recordTime = DateUtil.parse(tempTime);

                // 如果是将来的时间,就不执行查询,认为是没有数据的

                if (recordTime.isAfter(new Date())) {

                    resultMap.put(recordTime, null);

                    continue;

                }

                // 模拟从数据库拿到的温度,10.5 °C

                resultMap.put(recordTime, selectTemperature());

            }

        }

        return resultMap;

    }



    /**

     * 模拟从数据库查询数据,随机生成2到10之间的一个数字,保留一位小数

     *

     * @return 2到10之间的一个数字, 保留一位小数

     */

    private static float selectTemperature() {

        Random random = new Random();

        float minValue = 2.0f;

        float maxValue = 10.0f;

        float range = maxValue - minValue;

        float randomFloat = (random.nextFloat() * range) + minValue;

        DecimalFormat df = new DecimalFormat("#.0");

        String formattedFloat = df.format(randomFloat);

        return Float.parseFloat(formattedFloat);

    }



    /**

     * 获取起止时间内的每一天

     *

     * @param start 开始时间

     * @param end   结束时间

     * @return 每天

     */

    private static List<Date> getTimeRangeDates(Date start, Date end) {

        List<Date> dates = new ArrayList<>();

        DateTime current = DateUtil.date(start);

        DateTime endTime = DateUtil.date(end);

        while (current.isBefore(endTime)) {

            dates.add(current.toJdkDate());

            current = current.offset(DateField.DAY_OF_MONTH, 1);

        }

        return dates;

    }

经过上面一通操作，就可以得到了一个Map，里面的key是时间点，value是时间点对应的温度。
按道理来说，map已经构造好了，直接编写模板导出就完事了，就在这时，又碰到了一个问题，map上的{t1}、{t2}等占位符如何跟时间匹配的问题，模板上肯定是每个月都以最大的时间来定义，也就是31天，但并不是每个月都有31天，因此要在导出数据的时候把那些应该为空的占位符也计算出来，拿老王的模板来举例子：

今年是2023年，9月只有30天，那么模板上31号的占位符应该导出的时候就应该设置个空值，也就是在碰到{t93}的时候需要把值设置为空，然后再导出excel

完整代码如下：

package com.example.demo.test;



import cn.hutool.core.date.DateField;

import cn.hutool.core.date.DateTime;

import cn.hutool.core.date.DateUtil;

import com.alibaba.excel.EasyExcel;

import com.example.demo.handler.CustomCellWriteHandler;



import java.text.DecimalFormat;

import java.time.YearMonth;

import java.time.ZoneId;

import java.util.*;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.stream.Collectors;



public class ExportTest {



    public static void main(String[] args) {

        DateTime startTime = DateUtil.parse("2023-07-01 00:00:00");

        DateTime endTime = DateUtil.parse("2023-12-31 23:59:59");

        List<Date> timeRangeDates = getTimeRangeDates(startTime, endTime);

        List<String> times = Collections.singletonList("12");

        Map<DateTime, Float> resultMap = getTemperature(timeRangeDates, times);

        // 获取日期范围内的月份

        List<Integer> distinctMonths = getDistinctMonths(timeRangeDates);

        // 获取月份对应的天数

        Map<Integer, Integer> daysInMonths = getDaysInMonths(timeRangeDates);

        // 获取应该置空的下标

        List<Integer> emptyIndexList = getEmptyIndexList(daysInMonths, times.size());

        // 获取理论上一共有多少天,按照一个月31天算

        int totalDaysCount = getTotalDaysCount(distinctMonths, timeRangeDates.size());

        Map<String, Object> exportDataMap = new HashMap<>();

        // i快 j慢

        for (int i = 0, j = 0; i < totalDaysCount; i++) {

            int currentDateIndex = j;

            int currentCount = (i + 1) * times.size() - (times.size() - 1);

            for (String time : times) {

                // 本月不足31天的填充null

                if (emptyIndexList.contains(currentCount)) {

                    exportDataMap.put("t" + currentCount++, null);

                    continue;

                }

                // 12 ==> 2023-10-25 12:00:00

                String tempTime = DateUtil.formatDateTime(timeRangeDates.get(currentDateIndex))

                        .substring(0, 11) + time + ":00:00";

                if (currentDateIndex == j) {

                    j++;

                }

                // 根据date查询数据

                DateTime recordTime = DateUtil.parse(tempTime);

                exportDataMap.put("t" + currentCount++, resultMap.get(recordTime));

            }

        }

        // 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替

        String templateFileName = "F:/excel/" + "老王.xlsx";

        // 方案1 根据对象填充

        String fileName = "F:/excel/" + System.currentTimeMillis() + "老王.xlsx";

        EasyExcel.write(fileName).withTemplate(templateFileName)

                .registerWriteHandler(new CustomCellWriteHandler())

                .sheet().doFill(exportDataMap);

    }



    private static int getTotalDaysCount(List<Integer> distinctMonths, int timeRangeSize) {

        if (timeRangeSize <= 31) {

            return Math.min(distinctMonths.size() * 31, timeRangeSize);

        }

        return distinctMonths.size() * 31;

    }

    

    private static List<Integer> getEmptyIndexList(Map<Integer, Integer> daysInMonths, int pointCount) {

        List<Integer> list = new ArrayList<>();

        AtomicInteger count = new AtomicInteger();

        daysInMonths.forEach((key, value) -> {

            // 本月的开始长度

            int monthLength = count.get();

            // 总本月虚拟长度

            count.addAndGet(31 * pointCount);

            // 本月实际长度

            int realLength = value * pointCount;

            // 本月开始下标

            int startIndex = monthLength + realLength;

            // 多出的下标

            int extraCount = count.get() - realLength - monthLength;

            // 记录需要存空值的占位符位置

            for (int i = startIndex + 1; i <= startIndex + extraCount; i++) {

                list.add(i);

            }

        });

        return list;

    }

    

    /**

     * 获取今年的某些月份的天数

     *

     * @param timeRangeDates 时间范围

     * @return 该月份对应的年

     */

    private static Map<Integer, Integer> getDaysInMonths(List<Date> timeRangeDates) {

        List<Integer> distinctMonths = getDistinctMonths(timeRangeDates);

        Date firstDate = timeRangeDates.get(0);

        Calendar calendar = Calendar.getInstance();

        calendar.setTime(firstDate);

        int currentYear = calendar.get(Calendar.YEAR);

        return distinctMonths.stream()

                .collect(Collectors.toMap(

                        month -> month,

                        month -> YearMonth.of(currentYear, month).lengthOfMonth()

                ));

    }



    /**

     * 获取时间范围内的所有月份、去重、转成String类型

     *

     * @param timeRangeDates 时间范围集合

     * @return 月份集合

     */

    public static List<Integer> getDistinctMonths(List<Date> timeRangeDates) {

        return timeRangeDates.stream()

                .map(date -> date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate().getMonthValue())

                .distinct()

                .sorted()

                .collect(Collectors.toList());

    }



    /**

     * 获取要导出数据的Map, key为时间,value为时间对应的值

     *

     * @param timeRangeDates 时间范围

     * @param times          每天定义的时间点

     * @return 导出的map

     */

    private static Map<DateTime, Float> getTemperature(List<Date> timeRangeDates, List<String> times) {

        Map<DateTime, Float> resultMap = new HashMap<>();

        for (Date timeRangeDate : timeRangeDates) {

            for (String time : times) {

                // eg: 12 ==> 2023-11-07 12:00:00

                String tempTime = DateUtil.formatDateTime(timeRangeDate).substring(0, 11) + time + ":00:00";

                DateTime recordTime = DateUtil.parse(tempTime);

                // 如果是将来的时间,就不执行查询,认为是没有数据的

                if (recordTime.isAfter(new Date())) {

                    resultMap.put(recordTime, null);

                    continue;

                }

                // 模拟从数据库拿到的温度,10.5 °C

                resultMap.put(recordTime, selectTemperature());

            }

        }

        return resultMap;

    }



    /**

     * 模拟从数据库查询数据,随机生成2到10之间的一个数字,保留一位小数

     *

     * @return 2到10之间的一个数字, 保留一位小数

     */

    private static float selectTemperature() {

        Random random = new Random();

        float minValue = 2.0f;

        float maxValue = 10.0f;

        float range = maxValue - minValue;

        float randomFloat = (random.nextFloat() * range) + minValue;

        DecimalFormat df = new DecimalFormat("#.0");

        String formattedFloat = df.format(randomFloat);

        return Float.parseFloat(formattedFloat);

    }



    /**

     * 获取起止时间内的每一天

     *

     * @param start 开始时间

     * @param end   结束时间

     * @return 每天

     */

    private static List<Date> getTimeRangeDates(Date start, Date end) {

        List<Date> dates = new ArrayList<>();

        DateTime current = DateUtil.date(start);

        DateTime endTime = DateUtil.date(end);

        while (current.isBefore(endTime)) {

            dates.add(current.toJdkDate());

            current = current.offset(DateField.DAY_OF_MONTH, 1);

        }

        return dates;

    }

}

自定义设置样式

package com.example.demo.handler;



import com.alibaba.excel.write.handler.CellWriteHandler;

import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;

import lombok.extern.slf4j.Slf4j;

import org.apache.poi.ss.usermodel.*;



@Slf4j

public class CustomCellWriteHandler implements CellWriteHandler {



    @Override

    public void afterCellDispose(CellWriteHandlerContext context) {

        Cell cell = context.getCell();

        double numericCellValue;

        try {

            numericCellValue = cell.getNumericCellValue();

        } catch (Exception e) {

            log.error("解析到了非数值类型,直接返回");

            return;

        }

        if (numericCellValue >= 2 && numericCellValue <= 8) {

            return;

        }

        Workbook workbook = context.getWriteWorkbookHolder().getWorkbook();

        CellStyle cellStyle = workbook.createCellStyle();

        Font writeFont = workbook.createFont();

        writeFont.setColor(IndexedColors.RED.getIndex());

        writeFont.setBold(true);

        cellStyle.setFont(writeFont);

        cell.setCellStyle(cellStyle);

        context.getFirstCellData().setWriteCellStyle(null);

    }

}

运行效果如下：
9月31日有占位符，但是9月只有30日，因此31日无数据，并且数据不在2和8范围之间的数据都可以用红色字体展示

至于返回数据给前端这里就省略了，毕竟文件都能生成了，其他的都是小问题了

5. 小结

本次的设计实现了支持不同模板，按照月(月初到月末)、季度、半年的数据进行导出，初步实现了功能，但是面对更复杂的场景，例如需要支持不同模板在某一段时间的导出功能暂时没法实现。不过也算是积累了一次使用easyexcel导出报表的经验，以此来记录本次开发的过程，为后续类似功能的开发提供借鉴

代码存放链接: gitee.com/szq2021/eas… (主要是怕找不着了,先存着)

小菜的一次接口优化：从68474ms到1329ms

前言

突然，有人大喊一声：小菜，你过来一下

小菜被吓得抖了一抖，连忙切出开发界面，看了一眼，原来是项目经理在喊

小菜屁颠屁颠的过去后

项目经理：小菜，有空你看看后台管理里的商品信息导出Excel功能，导出数据只有几千条但是要等特别久

小菜：没问题，等我忙完手上的活就来看看怎么回事

分析与优化

小菜回到工位后，立马看了看后台管理系统的商品信息导出功能

该功能是通过导入规定格式的Excel（比如商品名称），然后导出这些商品的所有信息

小菜用对应的模板（大概数据量5千）使用此功能，大概等了1分钟多才导出结果

小菜：我可以先用arthas的trace监听这个接口，看看接口里哪些方法耗时，再具体进行分析

使用arthas的trace命令监听端口后，发现总耗时70284ms，其中XXMessage耗时68s，导出Excel花费1.8s

小菜：那具体的业务处理应该在XXMessage里了，我先来看看

     public List<ExportVO> xxMessage(MultipartFile file, HttpServletRequest request, HttpServletResponse response) {

         //导出结果

         List<ExportVO> exportVOS = new ArrayList<>();

         try {

             //EasyExcel 读取模板数据

             //使用AnalysisEventListener 在读取数据时加入导出结果，在读完后进行封装操作

             EasyExcel.read(file.getInputStream(), Product.class, new AnalysisEventListener<Product>() {

                 private final List<Product> list = new ArrayList<>();

 

                 //解析完一行后如何处理

                 @Override

                 public void invoke(Product p, AnalysisContext analysisContext) {

                     doLine(p);

                 }

 

                 //解析完所有数据后如何处理

                 @Override

                 public void doAfterAllAnalysed(AnalysisContext analysisContext) {

                     doAfter();

                 }

             }).sheet().doRead();

         } catch (IOException e) {

             e.printStackTrace();

         }

         return exportVOS;

     }

小菜：使用的EasyExcel读取，那真正的处理应该在实现的AnalysisEventListener中

小菜：让我先来看看每解析一行如何处理的

 //存储要处理的数据

 List<Product> products = new ArrayList<>();

 

 private void doLine(Product data) {

     try {

         //拿到所有使用ExcelProperty的字段 

         List<Field> fields = Arrays.stream(data.getClass().getDeclaredFields())

             .filter(f -> f.isAnnotationPresent(ExcelProperty.class))

             .collect(Collectors.toList());

         

         //判断字段是否为空，为空则集合添加false不为空添加true

         List<Boolean> lines = new ArrayList<>(fields.size());

         for (Field field : fields) {

             field.setAccessible(true);

             Object value = field.get(data);

             if (value == null) {

                 lines.add(Boolean.TRUE);

             } else {

                 lines.add(Boolean.FALSE);

             }

         }

         

         //ExcelProperty的所有字段不为空 就加入集合

         if(lines.stream().allMatch(Boolean.TRUE::equals)){

             products.add(data);

         }

     } catch (Exception e) {

         log.error("parse data fail: " + e.getMessage());

     }

 }

（ExcelProperty注解用于标记表格中的列）

小菜拿出做算法题分析时间复杂度的思路

小菜：这里总共有三个循环分别是：获取使用ExcelProperty的字段、判断每个字段是否为空、allMatch匹配数组中所有元素为true

小菜：那么用时间复杂度表示就是O（3N），N为数据量，而这些集合的数据量则是使用ExcelProperty的字段，好像是固定的，并不会随着Excel表格中数据量的提升而提升，那么可以把它们看成常量，那最终时间复杂度就是常量级别O（1）

小菜：但是还用了反射会有些性能开销

小菜：咦？为啥要判断实体每个字段不为空才加入要处理的集合呢？

小菜：好像直接判断该商品名不为空就可以了吧？

小菜：用反射来实现通用性，难道这段代码是前辈复制的？

于是，小菜洋洋得意的将代码改成：

 //存储要处理的数据

 List<Product> products = new ArrayList<>();

 

 private void doLine(Product data) {

     if (StringUtils.isNotEmpty(data.getProductName())) {

          products.add(data);

     }

 }

为了担心自己改错，小菜还保留原始代码，方便回滚

再来看下解析完数据后的处理方法

小菜看着这一望无际一百多行没有注释、多层if嵌套的代码，整个人都呆了

大致观看了一遍后，小菜将shit mountain代码梳理成以下代码：

 //存储要处理的数据

 List<Product> products = new ArrayList<>();

 

 private void doLine(Product data) {

     if (StringUtils.isNotEmpty(data.getProductName())) {

          products.add(data);

     }

 }

 

 private void doAfter() {

     //要处理的数据为空直接返回

     if (Empty.isEmpty(products)) {

         return;

     }

     

     //循环处理数据

     products.forEach(product->{

         //根据商品名查询出商品列表 IO

         List<Sku> skus = skuService.list(product.getProductName());

         //查到商品数据为空跳过

         if (Empty.isEmpty(skus)) {

             continue;

         }

         

         //查询商品具体数据 IO

         

         //查询分类、规格... IO

         

         //封装实体 添加到导出列表

     });

 }

看到这里小菜一下就明白为什么接口这么慢了

小菜：好好好，你这样写代码是吧

小菜：不考虑查数据库的网络IO是吧，肯定是不想写联表SQL，偷懒直接用MP

小菜直接用一次联表查询替代这么多的查询，为了避免数据量太大，小菜设置每次处理的最大数据量，分多次处理

 private void doAfter() {

     //要处理的数据为空直接返回

     if (Empty.isEmpty(products)) {

         return;

     }

     

     int batchSize = 520;

     //将大集合拆分为多个小集合 分批次处理

     List<List<Product>> lists = CollectionUtils.split(products,batchSize);

     

     //循环处理数据

     lists.forEach(products->{

         //转换为商品名列表

         List<String> productNames = products.stream().map(Product::getProductName).collect(Collectors.toList());

         //联表查询 IO

         List<SkuDetails> skus = skuService.list(productNames);

         skus.forEach(skus->{

             //封装实体 添加到导出列表

         });

     });    

 }

小菜优化完代码后，再用arthas监听一遍，发现这次只需要3s，速度提升近23倍

最后

接口优化的方式有很多种，在优化前我们需要进行分析哪里需要优化

在平时的开发中，也要多考虑时间、空间复杂度，并不是什么场景下都要去避免关联多张表查询

循环查数据库会造成多次网络IO，等待时间会很久，需要降低网络IO的次数，这种场景就可以联表查询

如果担心查的数据太多，联表查询性能慢，可以考虑分析执行计划增加索引，又或者分批次进行处理

其他接口优化的方式还有很多种，比如数据库优化、缓存、异步....

缓存，可以使用本地缓存、分布式缓存、多级缓存，但引入缓存又会带来一致性问题，要分析业务场景使用适合使用缓存

异步，可以使用MQ去做异步，也可以使用多线程去做异步，各有各的特点

在一些业务场景中，不要为了使用某项技术而去使用

技术是用来服务业务的，使用技术前要考虑到当前项目采用该技术是否合适，就像找伴侣一样，强扭的瓜不甜

有什么问题可以在评论区交流，如果觉得菜菜写的不错，可以点赞、关注、收藏支持一下~

关注菜菜，分享更多干货，公众号：菜菜的后端私房菜

彩蛋

小菜装作忧愁的来到项目经理旁边

小菜：经理，这个接口对应的实现有些复杂，我估计下周忙完手上的事情就可以优化，你先帮我提个需求吧

项目经理：ok没问题，下周忙完就尽快优化吧

这篇也是我分享里为数不多 “进阶” 与 “成长经历” 的文章之一。被别人送到嘴边的食物永远是最香的，但是咱们还是得学会主动去"如何找吃的"，授人以鱼不如授人以渔嘛，我希望通过这篇文章能给正在努力的你，迷茫的你，焦虑的你，带来或多或少的参考、建议或者指引。

十年，谁来成就你？

　　离开校园，一晃已十年，时日深久，现在我已成为程序员老鸟了，从软件工程师到系统架构师，从被管理者到部门负责人，每一段经历的艰辛，如今回忆仍历历在目。各位同行你们可能正在经历的迷茫，焦虑与取舍，我也都曾经历过。

　　今天我打算跟大家分享下我这些年的一个成长经历，以此篇文章为我十年的职业历程画上一个完满的句号。这篇文章虽说不是什么“绝世武功”秘籍，更没法在短时间内把我十年的“功力”全部分享于你。篇幅受限，今天我会结合过往种种挑重点说一说，大家看的过程中，记住抓重点、捋框架思路就行了。希望在茫茫人海之中，能够给到正在努力的你或多或少的帮助，亦或启发与思考。

试问，你的核心竞争力在哪？

　　你曾经是否怕被新人卷或者代替？如果怕、担忧、焦虑，我可以很负责任地告诉你，那是因为你的核心竞争力还不够！这话并不好听，但，确是实在话。认清现状，踏实走好当下就行，谁能一开始或者没破茧成蝶时就一下子有所成就。

　　实质上，可以这么说，经验才是我们职场老鸟的优势。 但是，经验并不是把同一件事用同一种方式重复做多少年，而是把咱们过往那么多年头的实践经验，还有被验证的理论，梳理成属于自己的知识体系，建立一套自己的思维模式，从而提升咱们的核心竞争力。

 　  核心竞争力的形成，并非一蹴而就，我们因为积累所以专业，因为专业所以自信，因为自信所以才有底气。积累、专业、自信、底气之间的关系，密不可分。

核心竞争力，祭出三板斧

　　道理咱们都懂，能不能来点实在的？行！每当身边朋友或者后辈们，希望我给他们传授一些“功力”时，我都会给出这样的三个建议：

1. 多面试，验本事。


2. 写博客，而且要坚持写。


3. 拥有自己的 Github 项目。 

　　其中，博客内容和 Github 项目，将会成为咱们求职道路上的门面，这两者也是实实在在记录你曾经的输出，是非常有力有价值的证明。此外，面试官可以通过咱们的博客和 Github，在短时间内快速地了解你的能力水平等。或许你没有足够吸引、打动人的企业背景，也没有过硬的学历。但！必须有不逊于前两者的作品跟经历。

　　再说说面试，我认为，它是我们接受市场与社会检验的一种有效方式。归根结底，咱们所付出的一切，都是为了日后在职业发展上走得越来越好。有朋友会说，面试官看这俩“门面”几率不大，没错，从我多年的求职经历来看，愿意看我作品的面试官也只占了 30%。

　　但是，谁又能预判到会不会遇到个好机会呢？有准备，总比啥也没有强，千里马的亮点是留给赏识它的伯乐去发现的。

PS：拥有自己 Github 项目与写博，都属于一种输出的方式，本文就以写博作为重点分享。写博与面试会在下文继续展开。

记忆与思考，经验与思维

　　武器（三板斧）咱们已经有了，少了“内功心法”也不行。这里分享下我的一些观点，也便于大家后续能够更好地参与到具体的实践中。

• 
  

  记忆——记忆如同对象一样是具有生命周期，久了不用就会被回收（忘记）。

  
  


• 
  

  思考——做任何事情就如同咱们写代码Function一样，得有输入同时也得有输出，输入与输出之间还得有执行。

  
  


• 
  

  ---

  
  

   

  
  

　　日常工作中，就拿架构设计当例子。作为架构师是需要针对现有的问题场景提出解决方案，作为架构师的思考输入是业务场景、团队成员、技术选型等，而它的输出就是基于前面的多种输入参数从而产出的短期或长期的解决方案，而且最终会以文档形式保存下来。

　　保存下来的目的，是为方便我们日后检索、回忆、复用。因此，在业余学习中同理，给与我们的输入是书籍、网络的资料或同行的传递等，而作为输出则是咱们记录下来的笔记、博客甚至是 Github 的项目 Demo。