大家好，作为今年刚毕业的大聪明（小🐂🐎），知道今年不好就业，费心费力的面试终于进了个小公司，然后我的奇妙之旅开始了。

叮！闹钟响了！牙都不刷了，直接起床出门去上班，身为🐂🐎就要有早起吃草干活的觉悟，所以我是个很合格的食草动物。只不过，下面的信息，让我一天当动物的好心情都没了。

部署？因为该公司人数比较少，也没有自动化部署操作，只能让前端build一下dist包然后丢给后端，让后端部署，然后该项目也比较急，我刚来，也不好意思@后端，恰巧跟我对接的后端也是刚来不熟悉，所以我就跟负责人继续扯皮拖延时间了。（真是不好意思，假的）↓↓↓

终于经过不断努力（后端），部署好了，但是，我的样式乱了，为什么呢？看了一下网络和源代码，样式文件都请求到了，问了后端，一致说是我前端的问题，我懵了，然后快马加鞭查找问题

解决

ok，那我先看打包的dist文件有样式有问题吗，使用npm安装个 http-server 运行打包后的index.html，运行打开运行后的地址，欧克样式没乱，文件引用也没问题，那到底是什么鬼影响的呢？

在我百思不得其解的时候，我打开了神器--csdn，搜索打包dist部署后样式文件不生效，就遇到了这个神文t.csdnimg.cn/WbQyq
欧克，按照博主说的Nginx没有配置这两个东西而导致的，我有点不确定是不是，有点犹犹豫豫的找到后端说帮我在Nginx配置文件的http加下这两个配置，然后样式就好了，完美！后端由于疏忽，没加上就把问题推给我，结果被我扳回一城。

include   mime.types;

default_type  application/octet-stream;

总之，添加 include mime.types; 和 default_type application/octet-stream; 配置后，Nginx能够正确地识别和处理CSS文件的MIME类型，从而确保浏览器能够正确加载和应用CSS样式。

所以，前端仔不能只当前端仔，还是要好好学点服务端的知识，不然锅给你，你还认为这是你该背的锅。

以上是开玩笑的描述，只是为了吸引增加阅读量

在一个美好的周末，闲来无事，约上朋友一起在家打麻将，奈何尘封已久的麻将包里翻来翻去也没找到骰子的踪影，于是想在网上找一个骰子模拟器来代替，找了半天都没有发现一款合适好用的软件，于是心血来潮，打算自己做一个🎲模拟器。

1.制定需求设计以及技术方案

1.骰子模型

• 用户可以选择多种骰子模型，如六面 15面 20面等不同风格的供选择


• 并且可以选择要投掷骰子的数量 暂定1-10

2.分数计算规则

• 每次投掷完后会自动计算总点数并显示在屏幕上


• 可以保存历史摇骰子记录 最多支持历史100条记录


• 可以自定义用户参与摇骰子，投掷完成后会显示：luke摇出了xx点。。并且保存在历史记录中


• 支持多人参与摇骰子比赛：比如先加入4名玩家，开始后会依次提示轮到哪位玩家来开始投掷，并且可以选择每局大家需要投掷的次数，最后会统计总点数以及排名。

3.动画特效

• 每次投掷时对骰子随机一个角度以及投掷方向，如果同时投掷多个骰子则随机每一个骰子的角度，给骰子施加一个向赌盘中心的力，让骰子随机落在赌盘中部，在赌盘周围增加一道空气墙来阻止骰子移动到牌桌外。


• 模拟不同骰子的落地音效

4.技术实现

• 利用threejs来实现webgl相关渲染。如骰子模型、场景渲染、相机、棋盘等。


• 利用cannosjs来模拟物理引擎。如骰子碰撞检测、抛出坠落动画、重力加速等物理效果。

2.效果展示

3.开始实现

准备3d骰子模型和棋盘素材

首先是找到合适的gltf模型，这里我们在sketchfab上找到了一款质感很真实的骰子模型。下载下来的模型可以通过gltf-viewer来查看模型效果。
棋盘的话其实是一张图片平铺起来的，这里我用了一张木地板图片。

引入资源以及初始化webgl场景

import * as CANNON from "cannon-es";

import * as THREE from 'three';

import { OrbitControls } from 'three/addons/controls/OrbitControls.js';

import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';

import { GUI } from 'three/addons/libs/lil-gui.module.min.js';





const scene = new THREE.Scene();

const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);

const renderer = new THREE.WebGLRenderer();

renderer.setSize(window.innerWidth, window.innerHeight);

document.body.appendChild(renderer.domElement);



//创建物理世界对象

const world = new CANNON.World();

// 设置物理世界重力加速度

world.gravity.set(0, -100, 0);  //重力加速度： 单位：m/s²

创建物理模型、地面以及网格模型地面

这里简单叙述一下物理世界和webgl世界的联系以及如何在webgl场景里模拟出真实的物理效果。

• 首先在three创建的webgl场景是无法直接创建并感知到物理世界的，threejs只负责实时渲染物理的状态并展示在画布上。而cannos恰好相反，它不负责渲染，只负责创建一个物理世界以及具备物理引擎的物体，并根据物体状态实时计算物体的位置、角度等。并把这些信息实时同步给webgl场景中的模型，把模型渲染到页面上实现物理世界的可视化。


• 所以我们创建骰子、地面等模型都需要创建两份。一份在webgl中创建，一份在物理世界中创建，并且保持同样的尺寸。
  
  

    //创建骰子网格模型（gltf模型）
  
    const loader = new GLTFLoader();
  
    const gltf = await loader.loadAsync('./assets/model/dice_model.glb');
  
  
  
    const meshModel = gltf.scene;//获取箱子网格模型
  
    meshModel.position.set(50,30,50);
  
    meshModel.scale.set(5,5,5);
  
    scene.add(meshModel);
  
  
  
    //包围盒计算
  
    const box3 = new THREE.Box3();
  
    box3.expandByObject(meshModel);//计算模型包围盒
  
    const size = new THREE.Vector3();
  
    box3.getSize(size);//包围盒计算箱子的尺寸
  
  
  
    // 创建骰子物理模型
  
    const sphereMaterial = new CANNON.Material()//碰撞体材质
  
    // 物理正方体
  
    const bodyModel = new CANNON.Body({
  
        mass: 0.3, // 碰撞体质量0.3kg
  
        position: new CANNON.Vec3(50,30,50), // 位置
  
        shape: new CANNON.Box(new CANNON.Vec3(size.x/2, size.y/2, size.z/2)),
  
        material: sphereMaterial
  
    });
  
    
  
    
  
    // 物理地面
  
    const groundMaterial = new CANNON.Material()
  
    const groundBody = new CANNON.Body({
  
        mass: 0, // 质量为0，始终保持静止，不会受到力碰撞或加速度影响
  
        shape: new CANNON.Plane(),
  
        material: groundMaterial,
  
    });
  
    // 改变平面默认的方向，法线默认沿着z轴，旋转到平面向上朝着y方向
  
    groundBody.quaternion.setFromEuler(-Math.PI / 2, 0, 0);//旋转规律类似threejs 平面
  
    world.addBody(groundBody)
  
  
  
    //设置物理世界参数
  
    const contactMaterial = new CANNON.ContactMaterial(groundMaterial, sphereMaterial, {
  
        restitution: 0.5, //反弹恢复系数
  
    })
  
    // 把关联的材质添加到物理世界中
  
    world.addContactMaterial(contactMaterial)
  
  
  
  
  
    // 网格地面
  
    const planeGeometry = new THREE.PlaneGeometry(1000, 1000);
  
    const texture = new THREE.TextureLoader().load('./assets/textures/hardwood2_diffuse.jpg');
  
    texture.wrapS = THREE.RepeatWrapping;
  
    texture.wrapT = THREE.RepeatWrapping;
  
    texture.repeat.set(10, 10);
  
    const planeMaterial = new THREE.MeshLambertMaterial({
  
        // color:0x777777,
  
        map: texture,
  
    });
  
    const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial);
  
    planeMesh.rotateX(-Math.PI / 2);
  
    scene.add(planeMesh);
  
  

  
  

创建好模型后，我们在创建光源，相机等，这里就不再赘述。接下来我们开始设计物理世界的骰子抛出后坠落效果，并将物理世界和webgl渲染同步。

    //点击屏幕后，设置物理骰子的角度和速度，物理会向上抛出并随着重力下落，触碰到地面后则会发生碰撞反弹

    renderer.domElement.addEventListener('click', function (event) {

        start_throw = true;

        clearPoints();

        const randomEuler = Math.random()*3;

        bodyModel.quaternion.setFromEuler(Math.PI / randomEuler, Math.PI / randomEuler, Math.PI / randomEuler);

        bodyModel.position.set(0,50,0);//点击按钮，body回到下落的初始位置

        // 为物体设置初始速度（用以产生抛物线效果）

        bodyModel.velocity.set(option.x,option.y,option.z); // x, y, z 方向上的速度

        // 选中模型的第一个模型，开始下落

        world.addBody(bodyModel);

    })

    

    function render() {

        world.step(1/60);//更新物理计算

        meshModel.position.copy(bodyModel.position);  //渲染循环中，同步物理球body与网格球mesh的位置

        meshModel.quaternion.copy(bodyModel.quaternion);   //同步姿态角度

        locateView();   //相机跟随物体移动

        requestAnimationFrame(render);

        renderer.render(scene, camera);

        if (isBodyStopped(bodyModel)&&start_throw) {

            showPoints();   //停止运动后，显示点数

            start_throw = false;

        }

    }

    render();//根据帧数渲染

    

接下来，我们再添加骰子点数计算相关逻辑。

//获取朝上面的点数

function getUpperFace(mesh) {

    // 定义每个面的局部法线向量（手动定义）

    const localNormals = [

        new THREE.Vector3(0, 1, 0),  // 面1

        new THREE.Vector3(0, 0, -1),  // 面2

        new THREE.Vector3(-1, 0, 0), // 面3

        new THREE.Vector3(1, 0, 0),  // 面4

        new THREE.Vector3(0, 0, 1),  // 面5

        new THREE.Vector3(0, -1, 0), // 面6

    ];

    

    let maxDot = -Infinity;

    let faceValue = 0;

    for (let i = 0; i < localNormals.length; i++) {

        // 将局部法线向量转化为世界空间

        const worldNormal = localNormals[i].clone().applyQuaternion(mesh.quaternion);

    

        // 与全局上方向的点积

        const dot = worldNormal.dot(new THREE.Vector3(0, 1, 0));

    

        // 检查点积，找到最大值

        if (dot > maxDot) {

            maxDot = dot;

            faceValue = i + 1; // 面的点数即为索引加1

        }

    }

    

    return faceValue;

}

//判断物体是否停止运动

function isBodyStopped(body, linearVelocityThreshold = 0.1, angularVelocityThreshold = 0.1) {

    // 获取物体的线性速度和角速度

    const linearVelocityMagnitude = body.velocity.length();

    const angularVelocityMagnitude = body.angularVelocity.length();



    // 判断速度是否低于设定的阈值

    return linearVelocityMagnitude < linearVelocityThreshold && angularVelocityMagnitude < angularVelocityThreshold;

}

//展示点数

function showPoints() {

    let res = getUpperFace(meshModel);

    let point = document.getElementById("points");

    point.innerHTML = `点数：${res}`

}

//清空点数

function clearPoints() {

    let point = document.getElementById("points");

    point.innerHTML = ``

}

实现这些逻辑后，我们已经可以模拟出骰子抛出坠落并触碰地面后反弹，在停止运动后计算点数的效果。已经实现基础功能，但是我们发现如果随机速度过大的时候会移动很远才停下，于是我们增加一个空气墙来限制骰子在固定范围内。并且增加一个碰撞检测来触发撞地声音的效果。

//添加空气墙

const wallShape = new CANNON.Box(new CANNON.Vec3(100, 100, 0.1));

    

const wall1 = new CANNON.Body({ mass: 0 });

wall1.addShape(wallShape);

wall1.position.set(0, 100, -100); // Back wall

world.addBody(wall1);



const wall2 = new CANNON.Body({ mass: 0 });

wall2.addShape(wallShape);

wall2.position.set(0, 100, 100); // Front wall

world.addBody(wall2);



const wall3 = new CANNON.Body({ mass: 0 });

wall3.addShape(wallShape);

wall3.quaternion.setFromEuler(0, Math.PI / 2, 0); // Rotate for side walls

wall3.position.set(100, 100, 0); // Right wall

world.addBody(wall3);



const wall4 = new CANNON.Body({ mass: 0 });

wall4.addShape(wallShape);

wall4.quaternion.setFromEuler(0, Math.PI / 2, 0); // Rotate for side walls

wall4.position.set(-100, 100, 0); // Left wall

world.addBody(wall4);



//监听物体碰撞回调

const audio = new Audio('./assets/audio/peng.mp3');

bodyModel.addEventListener('collide', (event) => {

    const contact = event.contact;

    //获得沿法线的冲击速度

    const ImpactV = contact.getImpactVelocityAlongNormal();

    // 碰撞越狠，声音越大

    if(ImpactV/35>1) {

        audio.volume = 1;

    } else {

        audio.volume = ImpactV/35>0?ImpactV/35:0;

    }

    audio.currentTime = 0;

    audio.play();

})

这样我们就初步完成了抛掷一个骰子并获取点数的功能，看似简单的一个场景实际上设计起来并不容易，要考虑很多因素。后续我会继续增加多个骰子同时抛掷的场景，以及比赛模式。源码也会贡献出来供大家一起学习参考，如果有更好的idea也可以在评论区留言或私信，大家一起在webgl中感受物理世界的魅力！

• 效果展示：codesandbox.io/p/github/lu…


• 源码地址：github.com/lukeSuperCo…

附完整代码：

import * as CANNON from "cannon-es";

import * as THREE from 'three';

import { OrbitControls } from 'three/addons/controls/OrbitControls.js';

import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';

import { GUI } from 'three/addons/libs/lil-gui.module.min.js';





const scene = new THREE.Scene();

const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);

const renderer = new THREE.WebGLRenderer();

renderer.setSize(window.innerWidth, window.innerHeight);

document.body.appendChild(renderer.domElement);



// 实例化一个gui对象

// const gui = new GUI();

// //改变交互界面style属性

// gui.domElement.style.right = '0px';

// gui.domElement.style.width = '300px';



const option = {

    z: -24,

    x: -36,

    y: -17,

    z1: 1,

    x1: 1,

    y1: 1,

}

// //gui控制参数

// const folder_position = gui.addFolder('速度方向');

// folder_position.add(option, 'z', -100, 100);

// folder_position.add(option, 'x', -100, 100);

// folder_position.add(option, 'y', -100, 100);

// const folder_rotation = gui.addFolder('角度');

// folder_rotation.add(option, 'z1', -10, 10).step(0.1);

// folder_rotation.add(option, 'x1', -10, 10).step(0.1);

// folder_rotation.add(option, 'y1', -10, 10).step(0.1);



// CANNON.World创建物理世界对象

const world = new CANNON.World();

// 设置物理世界重力加速度

// world.gravity.set(0, -1000, 0); //重力加速度： 单位：m/s²

world.gravity.set(0, -100, 0);









//网格球体（gltf模型）

const loader = new GLTFLoader();

const gltf = await loader.loadAsync('./assets/model/dice_model.glb');



const meshModel = gltf.scene;//获取箱子网格模型

meshModel.position.set(50,30,50);

meshModel.scale.set(5,5,5);

scene.add(meshModel);



//包围盒计算

const box3 = new THREE.Box3();

box3.expandByObject(meshModel);//计算模型包围盒

const size = new THREE.Vector3();

box3.getSize(size);//包围盒计算箱子的尺寸



// 物理球体

const sphereMaterial = new CANNON.Material()//碰撞体材质

// 物理箱子

const bodyModel = new CANNON.Body({

    mass: 0.3, // 碰撞体质量0.3kg

    position: new CANNON.Vec3(50,30,50), // 位置

    shape: new CANNON.Box(new CANNON.Vec3(size.x/2, size.y/2, size.z/2)),

    material: sphereMaterial

});



// 骨骼辅助显示

const skeletonHelper = new THREE.SkeletonHelper(meshModel);

scene.add(skeletonHelper);



// world.addBody(bodyModel);



//添加空气墙

// Create air walls

const wallShape = new CANNON.Box(new CANNON.Vec3(100, 100, 0.1));

    

const wall1 = new CANNON.Body({ mass: 0 });

wall1.addShape(wallShape);

wall1.position.set(0, 100, -100); // Back wall

world.addBody(wall1);



const wall2 = new CANNON.Body({ mass: 0 });

wall2.addShape(wallShape);

wall2.position.set(0, 100, 100); // Front wall

world.addBody(wall2);



const wall3 = new CANNON.Body({ mass: 0 });

wall3.addShape(wallShape);

wall3.quaternion.setFromEuler(0, Math.PI / 2, 0); // Rotate for side walls

wall3.position.set(100, 100, 0); // Right wall

world.addBody(wall3);



const wall4 = new CANNON.Body({ mass: 0 });

wall4.addShape(wallShape);

wall4.quaternion.setFromEuler(0, Math.PI / 2, 0); // Rotate for side walls

wall4.position.set(-100, 100, 0); // Left wall

world.addBody(wall4);



camera.position.set(42,85,21)

camera.lookAt(0,10,0);



// 物理地面

const groundMaterial = new CANNON.Material()

const groundBody = new CANNON.Body({

    mass: 0, // 质量为0，始终保持静止，不会受到力碰撞或加速度影响

    shape: new CANNON.Plane(),

    material: groundMaterial,

});

// 改变平面默认的方向，法线默认沿着z轴，旋转到平面向上朝着y方向

groundBody.quaternion.setFromEuler(-Math.PI / 2, 0, 0);//旋转规律类似threejs 平面

world.addBody(groundBody)



//设置物理世界参数

const contactMaterial = new CANNON.ContactMaterial(groundMaterial, sphereMaterial, {

    restitution: 0.5, //反弹恢复系数

})

// 把关联的材质添加到物理世界中

world.addContactMaterial(contactMaterial)



//光源设置

const directionalLight = new THREE.DirectionalLight(0xffffff, 2);

directionalLight.position.set(20, 100, 10);

scene.add(directionalLight);





// 网格地面

const planeGeometry = new THREE.PlaneGeometry(1000, 1000);

const texture = new THREE.TextureLoader().load('./assets/textures/hardwood2_diffuse.jpg');

texture.wrapS = THREE.RepeatWrapping;

texture.wrapT = THREE.RepeatWrapping;

texture.repeat.set(10, 10);

const planeMaterial = new THREE.MeshLambertMaterial({

    // color:0x777777,

    map: texture,

});

const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial);

planeMesh.rotateX(-Math.PI / 2);

scene.add(planeMesh);



// 添加一个辅助网格地面

// const gridHelper = new THREE.GridHelper(50, 50, 0x004444, 0x004444);

// scene.add(gridHelper);





var controls = new OrbitControls(camera, renderer.domElement);

controls.enableDamping = true; // 允许阻尼效果

controls.dampingFactor = 0.25; // 阻尼系数



let start_throw = false;

renderer.domElement.addEventListener('click', function (event) {

    start_throw = true;

    clearPoints();

    const randomEuler = Math.random()*3;

    bodyModel.quaternion.setFromEuler(Math.PI / randomEuler, Math.PI / randomEuler, Math.PI / randomEuler);

    bodyModel.position.set(0,50,0);//点击按钮，body回到下落的初始位置

    // 为物体设置初始速度（用以产生抛物线效果）

    bodyModel.velocity.set(option.x,option.y,option.z); // x, y, z 方向上的速度

    // 选中模型的第一个模型，开始下落

    world.addBody(bodyModel);

})

const audio = new Audio('./assets/audio/peng.mp3');

bodyModel.addEventListener('collide', (event) => {

    const contact = event.contact;

    //获得沿法线的冲击速度

    const ImpactV = contact.getImpactVelocityAlongNormal();

    // 碰撞越狠，声音越大

    if(ImpactV/35>1) {

        audio.volume = 1;

    } else {

        audio.volume = ImpactV/35>0?ImpactV/35:0;

    }

    audio.currentTime = 0;

    audio.play();

})



//判断物体是否停止运动

function isBodyStopped(body, linearVelocityThreshold = 0.1, angularVelocityThreshold = 0.1) {

    // 获取物体的线性速度和角速度

    const linearVelocityMagnitude = body.velocity.length();

    const angularVelocityMagnitude = body.angularVelocity.length();



    // 判断速度是否低于设定的阈值

    return linearVelocityMagnitude < linearVelocityThreshold && angularVelocityMagnitude < angularVelocityThreshold;

}



function showPoints() {

    let res = getUpperFace(meshModel);

    let point = document.getElementById("points");

    point.innerHTML = `点数：${res}`

}



//相机跟随物体移动

function locateView() {

    camera.position.x = meshModel.position.x;

    camera.position.y = meshModel.position.y + 30;

    camera.position.z = meshModel.position.z + 20;

    camera.lookAt(meshModel.position)

}



function clearPoints() {

    let point = document.getElementById("points");

    point.innerHTML = ``

}

//获取朝上面的点数

function getUpperFace(mesh) {

    // 定义每个面的局部法线向量（手动定义）

    const localNormals = [

        new THREE.Vector3(0, 1, 0),  // 面1

        new THREE.Vector3(0, 0, -1),  // 面2

        new THREE.Vector3(-1, 0, 0), // 面3

        new THREE.Vector3(1, 0, 0),  // 面4

        new THREE.Vector3(0, 0, 1),  // 面5

        new THREE.Vector3(0, -1, 0), // 面6

    ];

    

    let maxDot = -Infinity;

    let faceValue = 0;

    for (let i = 0; i < localNormals.length; i++) {

        // 将局部法线向量转化为世界空间

        const worldNormal = localNormals[i].clone().applyQuaternion(mesh.quaternion);

    

        // 与全局上方向的点积

        const dot = worldNormal.dot(new THREE.Vector3(0, 1, 0));

    

        // 检查点积，找到最大值

        if (dot > maxDot) {

            maxDot = dot;

            faceValue = i + 1; // 面的点数即为索引加1

        }

    }

    

    return faceValue;

}

function render() {

    world.step(1/60);//更新物理计算

    meshModel.position.copy(bodyModel.position);  //渲染循环中，同步物理球body与网格球mesh的位置

    meshModel.quaternion.copy(bodyModel.quaternion);   //同步姿态角度

    locateView();   //相机跟随物体移动

    requestAnimationFrame(render);

    renderer.render(scene, camera);

    if (isBodyStopped(bodyModel)&&start_throw) {

        showPoints();   //停止运动后，显示点数

        start_throw = false;

    }

}

render();

因为工作的原因，我和一些外国前端开发有些交流。他们对于国内环境不了解，有时候会问出一些有趣的问题，大概是这些问题的启发，让我反复在思考一些更为深入的问题。

今天聊三个事情：

• 小程序
• 微前端
• 模块加载

小程序

每个行业都有一把银座，当坐上那把银座时，做什么便都是对的。

“我们为什么需要小程序？”

第一次被问到这个问题，是因为一个法国的同事。他被派去做一个移动端业务，刚好那个业务是采用小程序在做。于是一个法国小哥就在被痛苦的中文文档和黑盒逻辑中来回折磨着 🤦。

于是，当我们在有一次交流中，他问出了我这个问题：我们为什么需要小程序？

说实话，我试图解释了 19 年国内的现状，以及微信小程序推出时候所带来的便利和体验等等。总之，在我看来并不够深刻的见解。

即便到现在为止，每次当我使用小程序的时候，依旧会复现这个问题。在 ChatGPT 11 月份出来的时候，我也问了它这个很有国内特色的问题：

看起来它回答的还算不错，至少我想如果它来糊弄那些老外，应该会比我做的更好些。

但如果扪心自问，单从技术上来讲。以上这些事情，一定是有其他方案能解决的。

所以从某种程度上来看，这更像是一场截胡的商业案例：

应用市场

全世界的互联网人都知道应用市场是非常有价值的事情，可以说操作系统最值钱的部分就在于他们构建了自己的应用市场。

只要应用在这里注册发行，雁过拔毛，这家公司就是互联网世界里的统治阶级，规则的制定者。

反之则需要受制于人，APP 做的再大，也只是应用市场里的一个应用，做的好与坏还得让应用商店的评判。

另外，不得不承认的是，一个庞大如苹果谷歌这样的公司，他们的应用商店对于普通国内开发者来说，确实是有门槛的。

在国内海量的 APP 需求来临之前，能否提供一个更低成本的解决方案，来消化这些公司的投资？

毕竟不是所有的小企业都需要 APP，其实他们大部分需求 Web 就可以解决，但是 Web 没牌面啊，做 Web 还得砸搜索的钱才有流量。(某度搜索又做成那样...)

那做操作系统？太不容易，那么多人都溺死在水里了，这水太深。

那有没有一种办法可以既能构建生态，又有 APP 的心智，还能给入驻企业提供流量？

于是，在 19 年夏天，滨海大厦下的软件展业基地里，每天都在轮番播放着，做 XX小程序，拥抱下一个风口...

全新体验心智

小程序用起来挺方便的。

你有没有想过，这些美妙感觉的具体都来自哪些？以及这些真的是 Web 技术本身无法提供的吗？

1. 靠谱感，每个小程序都有约束和规范，于是你可以将他们整整齐齐的陈放在你的列表里，仿佛你已经拥有了这一个个精心雕琢的作品，相对于一条条记不住的网页地址和鱼龙混杂的网页内容来说，这让你觉得小程序更加的有分量和靠谱。
2. 安全感，沉浸式的头部，没有一闪而过的加载条，这一切无打扰的设计，都让你觉得这是一个在你本地的 APP，而不是随时可能丢失网页。你不会因为网速白屏而感到焦虑，尽管网络差的时候，你的 KFC 依旧下不了单 😂
3. 沉浸感，我不知道是否打开网页时顶部黑黑的状态栏是故意留下的，还是不小心的... 这些限制都让用户非常强烈的意识到这是一个网页而不是 APP，而小程序中虽然上面也存在一个空间的空白，但是却可以被更加沉浸的主题色和氛围图替代。网页这个需求做不了？我不信。

H5	小程序

4. 顺滑感，得益于 Native 的容器实现，小程序在所有的视图切换时，都可以表现出于原生应用一样的顺滑感。其实这个问题才是在很多 Hybrid 应用中，主要想借助客户端来处理和解决的问题。类似容器预开、容器切换等技术是可以解决相关问题的，只是还没有一个标准。

我这里没有提性能，说实话我不认为性能在小程序中是有优势的（Native 调用除外，如地图等，不是一个讨论范畴）。作为普通用户，我们感受到的只是离线加载下带来的顺滑而已。

而上述提到的许多优势，这对于一个高品质的 Web 应用来说是可以做得到的，但注意这里是高品质的 Web 应用。而这种“高品质”在小程序这里，只是入驻门槛而已。

心智，这个词，听起来很黑话，但却很恰当。当小程序通过长期这样的筛选，所沉淀出来一批这样品质的应用时。就会让每个用户即便在还没打开一个新的小程序之前，也有不错体验的心理预期。这就是心智，一种感觉跟 Web 不一样，跟 APP 有点像的心智。

打造心智，这件事情好像就是国内互联网企业最擅长做的事情，总是能从一些细微的差别中开辟一条独立的领域，然后不断强化灌输本来就不大的差异，等流量起来再去捞钱变现。

我总是感觉现在的互利网充斥着如何赚钱的想法，好像永远赚不够。“赚钱”这个事情，在这些公司眼里就是圈人圈地抢资源，看看谁先占得先机，别人有的我也得有，这好像是最重要的事情。

很少有企业在思考如何创造些没有的市场，创造些真正对技术发展有贡献，对社会发展有推动作用的事情。所以在国内互联网圈也充斥着一种奇怪的价值观，有技术的不一定比赚过钱的受待见。

管你是 PHP 还是 GO，管你是在做游戏还是直播带货，只要赚到钱就是高人。并且端的是理所应当、理直气壮，有些老板甚至把拍摄满屋子的程序员为自己打工作为一种乐趣。什么情怀、什么优雅、什么愿景，人生就俩字：搞钱。

不是故意高雅，赚钱这件事情本身不寒碜，只是在已经赚到盆满钵满、一家独大的时候还在只是想着赚更多的钱，好像赚钱的目的就是为了赚钱一样，这就有点不合适。企业到一定程度是要有社会责任的，龙头企业每一个决定和举措，都有会影响接下来的几年里这个行业的价值观走向。

当然也不是完全没有好格局的企业，我非常珍惜每一个值得尊重的中国企业，来自一个蔚来车主。

小程序在商业上固然是成功的，但吃的红利可以说还是来自 网页 到 应用 的心智变革。将本来流向 APP 的红利，截在了小程序生态里。

但对于技术生态的发展却是带来了无数条新的岔路，小程序的玩法就决定了它必须生长在某个巨型应用里面，不论是用户数据获取、还是 API 的调用，其实都是取决于应用容器的标准规范。

不同公司和应用之间则必然会产生差异，并且这种差异是墒增式的差异，只会随着时间的推移越变越大。如果每个企业都只关注到自己业务的增长，无外部约束的话，企业必然会根据自己的业务发展和政策需要，选择成本较低的调整 API，甚至会故意制造一些壁垒来增加这种差异。

小程序，应该是 浏览器 与 操作系统 的融合，这本应该是推动这两项技术操刀解决的事情。

微前端

qiankun、wujie、single-spa 是近两年火遍前端的技术方案，同样一个问题：我们为什么需要微前端？

我不确定是否每个在使用这项技术的前端都想清楚了这个问题，但至少在我面试过的候选人中，我很少遇到对自己项目中已经在使用的微前端，有很深的思考和理解的人。

先说下我的看法：

没有万能银弹

银色子弹（英文：Silver Bullet），或者称“银弹”“银质子弹”，指由纯银质或镀银的子弹。在欧洲民间传说及19世纪以来哥特小说风潮的影响下，银色子弹往往被描绘成具有驱魔功效的武器，是针对狼人、吸血鬼等超自然怪物的特效武器。后来也被比喻为具有极端有效性的解决方法，作为杀手锏、最强杀招、王牌等的代称。

所有技术的发展都是建立在前一项技术的基础之上，但技术依赖的选择过程中一定需要保留第一性原理的意识。

当 React、Vue 兴起，当 打包技术(Webpack) 兴起，当 网页应用(SPA) 兴起，这些杰出的技术突破都在不同场景和领域中给行业提供了新的思路、新的方案。

不知从何时开始，前端除了 div 竟说不出其他的标签(还有说 View 的)，项目中再也不会考虑给一个通用的 class 解决通用样式问题。

不知从何时开始，有没有权限需要等到 API 请求过后才知道，没有权限的话再把页面跳转过去申请。

不知从何时开始，大家的页面都放在了一个项目里，两个这样的巨石应用融合竟然变成了一件困难的事。

上面这些不合理的现状，都是在不同的场景下，不思考适不适合，单一信奉 “一招吃遍天” 下演化出的问题。

B 端应用，是否应该使用 SPA？ 这其实是一个需要思考的问题。

微前端从某种程度上来讲，是认准 SPA 了必须是互联网下一代应用标准的产物，好像有了 SPA 以后，MPA 就变得一文不值。甭管页面是移动端的还是PC的；甭管页面是面对 C 端的还是 B 端的；甭管一个系统是有 20 个页面还是 200 个页面，一律行这套逻辑。

SPA 不是万能银弹，React 不是万能银弹，Tailwind 不是万能银弹。在新技术出现的时候，保持热情也要保持克制。

ps. 我也十分痛恨 React 带来的这种垄断式的生态，一个 React 组件将 HTML 和 Style 都吃进去，让你即使在做一个移动端的纯展示页面时，也需要背上这些称重的负担。

质疑 “墨守成规”，打开视野，深度把玩，理性消费。

分而治之

分治法，一个很基本的工程思维。

在我看来在一个正常商业迭代项目中的主要维护者，最好不要超过 3 个人，注意是主要维护者(Maintainer) 。

你应该让每个项目都有清晰的责任人，而不是某行代码，某个模块。责任人的理解是有归属感，有边界感的那种，不是口头意义上的责任人。(一些公司喜欢搞这种虚头巴脑的事情，什么连坐…)

我想大部分想引入微前端的需求都是类似 如何更好的划分项目边界，同时保留更好的团队协同。

比如 导航菜单 应该是独立收口独立管理的，并且当其更新时，应该同时应用于所有页面中。类似的还有 环境变量、时区、主题、监控及埋点。微前端将这些归纳在主应用中。

而具体的页面内容，则由对应的业务进行开发子应用，最后想办法将路由关系注册进主应用即可。

当然这样纯前端的应用切换，还会出现不同应用之间的全局变量差异、样式污染等问题，需要提供完善的沙箱容器、隔离环境、应用之间通信等一系列问题，这里不展开。

当微前端做到这一部分的时候，我不禁在想，这好像是在用 JavaScript 实现一个浏览器的运行容器。这种本应该浏览器本身该做的事情，难道 JS 可以做的更好？

只是做到更好的项目拆分，组织协同的话，引入后端服务，由后端管控路由表和页面规则，将页面直接做成 MPA，这个方案或许并不比引入微前端成本高多少。

体验差异

从 SPA 再回 MPA，说了半天不又回去了么。

所以不防想想：在 B端 业务中使用 SPA 的优势在哪里？

流畅的用户体验：

这个话题其实涵盖范围很广，对于 SPA 能带来的 “流畅体验”，对于大多数情况下是指：导航菜单不变，内容变化 发生变化，页面切换中间不出现白屏。

但要做到这个点，其实对于 MPA 其实并没有那么困难，你只需要保证你的 FCP 在 500ms 以内就行。

以上的页面切换全部都是 MPA 的多页面切换，我们只是简单做了导航菜单的 拆分 和 SWR，并没有什么特殊的 preload、prefetch 处理，就得到了这样的效果。

因为浏览器本身在页面切换时会在 unload 之前先 hold 当前页面的视图不变，发起一下一个 document 的请求，当页面的视图渲染做到足够快和界面结构稳定就可以得到这样的效果。

这项浏览器的优化手段我找了很久，想找一篇关于它的博文介绍，但确实没找到相关内容，所以 500ms 也是我的一个大致测算，如果你知道相关的内容，可以在评论区补充，不胜感激。

所以从这个角度来看，浏览器本身就在尽最大的努力做这些优化，并且他们的优化会更底层、更有效的。

离线访问 (PWA)

SPA 确实会有更好的 PWA 组织能力，一个完整的 SPA 应用甚至可以只针对编译层做改动就可以支持 PWA 能力。

但如果看微前端下的 SPA 应用，需要支持 PWA 那就同样需要分析各子应用之间的元数据，定制 Service Worker。这种组织关系和定制 SW，对于元数据对于数据是来自前端还是后端，并不在意。

也就是说微前端模式下的 PWA，同样的投入成本，把页面都管理在后端服务中的 MPA 应用也是可以做到相同效果的。

项目协同、代码复用

有人说 SPA 项目下，项目中的组件、代码片段是可以相互之间复用的，在 MPA 下就相对麻烦。

这其实涉及到项目划分的领域，还是要看具体的需求也业务复杂度来定。如果说整个系统就是二三十个页面，这做成 SPA 使用前端接管路由高效简单，无可厚非。

但如果你本身在面对的是一个服务于复杂业务的 B 端系统，比如类似 阿里云、教务系统、ERP 系统或者一些大型内部系统，这种往往需要多团队合作开发。这种时候就需要跟完善的项目划分、组织协同和系统整合的方案。

这个时候 SPA 所体现出的优势在这样的诉求下就会相对较弱，在同等投入的情况下 MPA 的方案反而会有更少的执行成本。

也不是所有项目一开始就会想的那么清楚，或许一开始的时候就是个简单的 SPA 项目，但是随着项目的不断迭代，才变成了一个个复杂的巨石应用，现在如果再拆出来也会有许多迁移成本。引入微前端，则可以...

这大概是许多微前端项目启动的背景介绍，我想说的是：对于屎山，我从来不信奉“四两拨千斤”。

如果没有想好当下的核心问题，就引入新的“银弹”解决问题，只会是屎山雕花。

项目协同，抽象和复用这些本身不是微前端该解决的问题，这是综合因素影响下的历史背景问题。也是需要一个个资深工程师来把控和解决的核心问题，就是需要面对不同的场景给出不同的治理方案。

这个道理跟防沙治沙一样，哪有那么多一蹴而就、立竿见影的好事。

模块加载

模块加载这件事情，从玉伯大佬的成名作 sea.js 开始就是一个非常值得探讨的问题。在当时 jQuery 的时代里，这是一个绝对超前的项目，我也在实际业务中体会过在无编译的环境下 sea.js 的便捷。

实际上，不论是微前端、低代码、会场搭建等热门话题离不开这项技术基础。

import * from * 我们每天都在用，但最终的产物往往是一个自运行的 JS Bundle，这来自于 Webpack、Vite 等编译技术的发展。让我们可以更好的组织项目结构，以构建更复杂的前端应用。

模块的概念用久了，就会自然而然的在遇到浏览器环境中，遇到动态模块加载的需求时，想到这种类似模块加载的能力。

比如在遇到会场千奇百怪的个性化营销需求时，能否将模块的 Props 开放出来，给到非技术人员，以更加灵活的方式让他们去做自由组合。

比如在低代码平台中，让开发者自定义扩展组件，动态的将开发好的组件注册进低代码平台中，以支持更加个性的需求。

在万物皆组件的思想影响下，把一整个完整页面都看做一个组件也不是不可以。于是在一些团队中，甚至提倡所有页面都可以搭建、搭建不了的就做一个大的页面组件。这样及可以减少维护运行时的成本，又可以统一管控和优化，岂不美哉。

当这样大一统的“天才方案”逐渐发展成为标准后，也一定会出现一些特殊场景无法使用，但没关系，这些天才设计者肯定会提供一种更加天才的扩展方案出来。比如插件，比如扩展，比如 IF ELSE。再后来，就会有性能优化了，而优化的 追赶对象 就是用原来那种简单直出的方案。

有没有发现，这好像是在轮回式的做着自己出的数学题，一道接一道，仿佛将 1 + 1的结论重新演化了一遍。

题外话，我曾经自己实现过一套通过 JSON Schema 描述 React 结构的 “库” ，用于一个低代码核心层的渲染。在我的实现过程中，我越发觉得我在做一件把 JSX 翻译成 JS 的事情，但 JSX 或者 HTML 本身不就是一种 DSL 么。为什么一定要把它翻译成 JSON 来传输呢？或者说这样的封装其本身有意义么？这不就是在做 PHP、.Net 直接返回带有数据的 HTML Ajax 一样的事情么。

传统的浏览器运行环境下要实现一个模块加载器，无非是在全局挂载一个注册器，通过 Script 插入一段新的 JS，该 JS 通过特殊的头尾协议，将运行时的代码声明成一个函数，注册进事先挂载好的注册器。

但实际的实现场景往往要比这复杂的多，也有一些问题是这种非原生方式无法攻克的问题。比如全局注册器的命名冲突；同模块不同版本的加载冲突；并发加载下的时序问题；多次模块加载的缓存问题 等等等等等...

到最后发现，这些事情好像又是在用 JS 做浏览器该做的事情。然而浏览器果然就做了，，Vite 就主要采用这种模式实现了它 1 年之内让各大知名项目切换到 Vite 的壮举。

“但我们用不了，有兼容性问题。”

哇哦，当我看着大家随意写出的 display: grid 样式定义，不禁再次感叹人们对未知的恐惧。

import.meta 的兼容性是另外一个版本，是需要 iOS12 以上，详情参考：caniuse.com/?search=imp…

试想一下，现在的低代码、会场搭建等等各类场景的模块加载部分，如果都直接采用 ESM 的形式处理，这对于整个前端生态和开发体验来说会有多么大的提升。

模块加载，时至今日，本来就已经不再需要 loader。 正如 seajs 中写的：前端模块化开发那点历史

历史不是过去，历史正在上演。随着 W3C 等规范、以及浏览器的飞速发展，前端的模块化开发会逐步成为基础设施。一切终究都会成为历史，未来会更好。

结语

文章的结尾，我想感叹另外一件事，国人为什么一定要有自己的操作系统？为什么一定需要参与到一些规范的制定中？

因为我们的智慧需要有开花的土壤，国内这千千万开发者的抱负需要有地方释放。

如果没有自己掌握核心技术，就是只能在问题出现的时候用另类的方式来解决。最后在一番折腾后，发现更底层的技术只要稍稍一改就可以实现的更好。这就像三体中提到的 “智子” 一样，不断在影响着我们前进的动力和方向。

不论是小程序、微前端还是模块加载。试想一下，如果我们有自己的互联网底蕴，能决定或者影响操作系统和浏览器的底层能力。这些 “怪啖” 要么不会出现，要么就是人类的科技创新。

希望未来技术人不用再追逐 Write Once, Run Everywhere 的事情...

概述

几乎所有的系统都会面临安全认证相关的问题，但是安全相关的问题是一个很麻烦的事情。因为它不产生直接的业务价值，而且处理起来复杂繁琐，所以很多时都容易被忽视。很多后期造成重大的安全隐患，往往都是前期的不重视造成的。但庆幸的是安全问题是普遍存在的，而且大家面临的问题几乎相同，所以可以制定行业标准来规范处理，甚至是可以抽出专门的基础设施（例如：AD、LDAP 等）来专门解决这类共性的问题。总之，关于安全问题非常复杂而且麻烦，对于大多数 99% 的系统来说，不要想着在安全问题领域上搞发明和创新，容易踩坑。而且行业的标准解决方案已经非常成熟了。经过长时间的检验。所以在安全领域，踏踏实实的遵循规范和标准就是最好的安全设计。

HTTP 认证

HTTP 认证协议的最初是在 HTTP/1.1标准中定义的，后续由 IETF 在 RFC 7235 中进行完善。HTTP 协议的主要涉及两种的认证机制。

基本认证

常见的叫法是 HTTP Basic，是一种对于安全性不高，以演示为目的的简单的认证机制（例如你家路由器的登录界面），客户端用户名和密码进行 Base64 编码（注意是编码，不是加密）后，放入 HTTP 请求的头中。服务器在接收到请求后，解码这个字段来验证用户的身份。示例：

GET /some-protected-resource HTTP/1.1

Host: example.com

Authorization: Basic dXNlcjpwYXNzd29yZA==

虽然这种方式简单，但并不安全，因为 base64 编码很容易被解码。建议仅在 HTTPS 协议下使用，以确保安全性。

摘要认证

主要是为了解决 HTTP Basic 的安全问题，但是相对也更复杂一些，摘要认证使用 MD5 哈希函数对用户的密码进行加密，并结合一些盐值（可选）生成一个摘要值，然后将这个值放入请求头中。即使在传输过程中被截获，攻击者也无法直接从摘要中还原出用户的密码。示例：

GET /dir/index.html HTTP/1.1

Host: example.com

Authorization: Digest username="user", realm="example.com", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", uri="/dir/index.html", qop=auth, nc=00000001, cnonce="0a4f113b", response="6629fae49393a05397450978507c4ef1", opaque="5ccc069c403ebaf9f0171e9517f40e41"

**补充：**另在 RFC 7235 规范中还定义当用户没有认证访问服务资源时应返回 401 Unauthorized 状态码，示例：

HTTP/1.1 401 Unauthorized

WWW-Authenticate: Basic realm="Restricted Area"

这一规范目前应用在所有的身份认证流程中，并且沿用至今。

Web 认证

表单认证

虽然 HTTP 有标准的认证协议，但目前实际场景中大多应用都还是基于表单认证实现，具体步骤是：

常见的表单认证页面通常如下：

html>

<html>

<head>

    <title>Login Pagetitle>

head>

<body>

    <h2>Login Formh2>

    <form action="/perform_login" method="post">

        <div class="container">

            <label for="username"><b>Usernameb>label>

            <input type="text" placeholder="Enter Username" name="username" required>

            

            <label for="password"><b>Passwordb>label>

            <input type="password" placeholder="Enter Password" name="password" required>

            

            <button type="submit">Loginbutton>

        div>

    form>

body>

html>

为什么表单认证会成为主流 ？主要有以下几点原因：

• 界面美化：开发者可以创建定制化的登录界面，可以与应用的整体设计风格保持一致。而 HTTP 认证通常会弹出一个很丑的模态对话框让用户输入凭证。


• 灵活性：可以在表单里面自定义更多的逻辑和流程，比如多因素认证、密码重置、记住我功能等。这些功能对于提高应用的安全性和便利性非常重要。


• 安全性：表单认证可以更容易地结合现代的安全实践，背后也有 OAuth 2 、Spring Security 等框架的主持。

表单认证传输内容和格式基本都是自定义本没啥规范可言。但是在 2019 年之后 web 认证开始发布标准的认证协议。

WebAuthn

WebAuthn 是一种彻底抛弃传统密码的认证，完全基于生物识别技术和实体密钥作为身份识别的凭证（有兴趣的小伙伴可以在 github 开启 Webauhtn 的 2FA 认证体验一下）。在 2019 年 3 月，W3C 正式发布了 WebAuthn 的第一版规范。

相比于传统的密码，WebAuthn 具有以下优势：

总的来说，WebAuthn 是未来的身份认证方式，通过提供一个更安全、更方便的认证方式，目的是替代传统的基于密码的登录方法，从而解决了网络安全中的一些长期问题。WebAuthn 目前已经得到流程的浏览器厂商（Chrome、Firefox、Edge、Safari）、操作系统（WIndows、macOS、Linux）的广泛支持。

实现效果

当你的应用接入 WebAuthn 后，用户便可以通过生物识别设备进行认证，效果如下：

实现原理

WebAuthn 实现较为复杂，这里不做详细描述，具体可参看权威的官方文档，大概交互过程可以参考以下时序图：

登录流程大致可以分为以下步骤：

WebAuthn 采用非对称加密的公钥、私钥替代传统的密码，这是非常理想的认证方案，私钥是保密的，只有验证器需要知道它，连用户本人都不需要知道，也就没有人为泄漏的可能；

备注：你可以通过访问 webauthn.me 了解到更多消息的信息

文章不适合加入过多的演示代码，想要手上体验的可以参考 okta 官方给出基于 Java 17 和 Maven 构建的 webauthn 示例程序，如下：

• 访问地址：github.com/oktadev/web…

一、需求背景

我们知道Spring Boot项目，是可以通过java -jar 包名 启动的。

那为什么Spring Boot项目可以通过上述命令启动，而其它普通的项目却不可以呢？

原因在于我们在通过以下命令打包时

mvn clean package

一般的maven项目的打包命令，不会把依赖的jar包也打包进去的，所以这样打出的包一般都很小

但Spring Boot项目的pom.xml文件中一般都会带有spring-boot-maven-plugin插件。

该插件的作用就是会将依赖的jar包全部打包进去。该文件包含了所有的依赖和资源文件。

也就会导致打出来的包比较大。

打完包就可以通过java -jar 包名 启动,确实是方便了。

但当一个系统上线运行后，肯定会有需求迭代和Bug修复，那也就免不了进行重新打包部署。

我们可以想象一种场景，线上有一个紧急致命Bug,你也很快定位到了问题，就改一行代码的事情，当提交代码并完成构建打包并交付给运维。

因为打包的jar很大，一直处于上传中.......

如果你是老板肯定会发火，就改了一行代码却上传几百MB的文件,难道没有办法优化一下吗？

如今迭代发布是常有的事情，每次都上传一个如此庞大的文件，会浪费很多时间。

下面就以一个小项目为例，来演示如何瘦身。

二、瘦身原理

这里有一个最基础 SpringBoot 项目，整个项目代码就一个SpringBoot启动类，单是打包出来的jar就有20多M；

我们通过解压命令，看下jar的组成部分。

tar -zxvf spring-boot-maven-slim-1.0.0.jar

我们可以看出,解压出来的包有三个模块

分为 BOOT-INF，META-INF，org 三个部分

打开 BOOT-INF

classes: 当前项目编译好的代码是放在 classes 里面的,classes 部分是非常小的。

lib: 我们所依赖的 jar 包都是放在 lib 文件夹下,lib部分会很大。

看了这个结构我们该如何去瘦身呢？

项目虽然依赖会很多，但是当版本迭代稳定之后，依赖基本就不会再变动了。

如果可以把这些不变的依赖提前都放到服务器上，打包的时候忽略这些依赖，那么打出来的Jar包就会小很多，直接提升发版效率。

当然这样做你肯定有疑问？

既然打包的时候忽略这些依赖，那通过java -jar 包名 还可以启动吗？

这种方式打的包，在项目启动时，需要通过-Dloader.path指定lib的路径,就可以正常启动

java -Dloader.path=./lib -jar xxx.jar

三、瘦身实例演示

1、依赖拆分配置

只需要在项目pom.xml文件中添加下面的配置：

 <build>

  <plugins>

   <plugin>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-maven-plugin</artifactId>

    <configuration>

     <executable>true</executable>

     <layout>ZIP</layout>

     <!--这里是填写需要包含进去的jar，

          必须项目中的某些模块，会经常变动，那么就应该将其坐标写进来

          如果没有则nothing ，表示不打包依赖 -->

     <includes>

      <include>

       <groupId>nothing</groupId>

       <artifactId>nothing</artifactId>

      </include>

     </includes>

    </configuration>

   </plugin>



   <!--拷贝依赖到jar外面的lib目录-->

   <plugin>

    <groupId>org.apache.maven.plugins</groupId>

    <artifactId>maven-dependency-plugin</artifactId>

    <executions>

     <execution>

      <id>copy</id>

      <phase>package</phase>

      <goals>

       <goal>copy-dependencies</goal>

      </goals>

      <configuration>

       <!--指定的依赖路径-->

       <outputDirectory>

        ${project.build.directory}/lib

       </outputDirectory>

      </configuration>

     </execution>

    </executions>

   </plugin>

  </plugins>

 </build>

再次打包

mvn clean package

发现target目录中多了个lib文件夹，里面保存了所有的依赖jar。

自己业务相关的jar也只有小小的168kb，相比之前20.2M，足足小了100多倍；

这种方式打的包，在项目启动时，需要通过-Dloader.path指定lib的路径：

java -Dloader.path=./lib -jar spring-boot-maven-slim-1.0.0.jar

虽然这样打包，三方依赖的大小并没有任何的改变，但有个很大的不同就是我们自己的业务包和依赖包分开了；

在不改变依赖的情况下，也就只需要第一次上传lib目录到服务器，后续业务的调整、bug修复，在没调整依赖的情况下，就只需要上传更新小小的业务包即可；

2、自己其它项目的依赖如何处理?

我们在做项目开发时，除了会引用第三方依赖，也会依赖自己公司的其它模块。

比如

这种依赖自己其它项目的工程，也是会经常变动的，所以不宜打到外部的lib，不然就会需要经常上传更新。

那怎么做了?

其实也很简单 只需在上面的插件把你需要打进jar的填写进去就可以了

<plugin>

 <groupId>org.springframework.boot</groupId>

 <artifactId>spring-boot-maven-plugin</artifactId>

 <configuration>

  <executable>true</executable>

  <layout>ZIP</layout>

  <!--这里是填写需要包含进去的jar，如果没有则nothing -->

   <includes>

    <include>

     <groupId>com.jincou</groupId>

     <artifactId>xiaoxiao-util</artifactId>

    </include>

   </includes>

 </configuration>

</plugin>

这样只有include中所有添加依赖依然会打进当前业务包中。

四、总结

使用瘦身部署，你的业务包确实小了 方便每次的迭代更新，不用每次都上传一个很大的 jar 包，从而节省部署时间。

但这种方式也有一个弊端就是增加了Jar包的管理成本，多人协调开发，构建的时候，还需要专门去关注是否有人更新依赖。

目前开发安卓TV的方法相对开说是十分的少的，使用uniapp开发相对来说几乎是没有的，因此，写下这篇文章供大家参考。

开发难点

一、如何方便的开发调试

之前我在论坛看到人家说，没办法呀，电脑搬到电视，然后调试。

其实大可不必，安装android studio里边创建一个模拟器就可以了。

注意:最好安装和电视系统相同的版本号，我这里是长虹电视，安卓9所以使用安卓9的sdk

二、如何使需要被聚焦的元素获取聚焦状态

uniapp的本质上是webview, 因此我们可以在它的元素上添加tabIndex， 就可以获取焦点了。

  <view class="card" tabindex="0">

    <image :src="`${VITE_URL}${props.image}`" fade-show lazy-load mode="aspectFill"></image>

    <view class="bottom">

      <text class="name">{{ props.name }}</text> <text class="remark">{{ props.remark }}</text>

      <div class="footer">

        <view class="tags">

          <text class="tag" v-for="tag in tags" :key="tag">{{ tag }}</text>

        </view>

        <text class="price">&yen; {{ props.price }}</text>

      </div>

    </view>

  </view>

  

  

 .card {

  border-radius: 1.25vw;

  overflow: hidden;

}

.card:focus {

  box-shadow: 0 0 0 0.3vw #fff, 0 0 1vw 0.3vw #333;

  outline: none;

  transform: scale(1.03);

  transition: box-shadow 0.3s ease, transform 0.3s ease;

}

三、如何使被聚焦的元素滚动到视图中心位置

使用renderjs进行实现如下

<script  module="homePage" lang="renderjs">

export default {

  mounted() {

    let isScrolling = false; // 添加一个标志位，表示是否正在滚动

    document.body.addEventListener('focusin', e => {

      if (!isScrolling) {

        // 检查是否正在滚动

        isScrolling = true; // 设置滚动标志为true

        requestAnimationFrame(() => {

          // @ts-ignore

          e.target.scrollIntoView({

            behavior: 'smooth', // @ts-ignore

            block: e.target.dataset.index ? 'end' : 'center'

          });

          isScrolling = false; // 在滚动完成后设置滚动标志为false

        });

      }

    });

  }

};

</script>

就可以使被聚焦元素滚动到视图中心，requestAnimationFrame的作用是缓存

四、如何在切换路由时，缓存聚焦的状态

通过设置tabindex属性为0和1，会有不同的效果：

需要注意的是，如果给多个元素都设置了tabindex属性，那么它们的焦点顺序将取决于它们的tabindex值，数值越小的元素将优先获取焦点。如果多个元素具有相同的tabindex值，则它们将按照它们在文档中的位置来确定焦点顺序。同时，负数的tabindex值也是有效的，它们将优先于零和正数值获取焦点。

我们要安装缓存插件，如pinia或vuex,需要缓存的页面单独配置

import { defineStore } from 'pinia';

export const useGlobalStore = defineStore('global', {

  state: () => ({ home_active_tag: 'active0', hot_active_tag: 'hot0', dish_active_tag: 'dish0' })

});

更新一下业务代码

组件区域

<view class="card" :tabindex="home_active_tag === 'packagecard' + props.id ? 1 : 0">

    <image :src="`${VITE_URL}${props.image}`" fade-show lazy-load mode="aspectFill"></image>

    <view class="bottom">

      <text class="name">{{ props.name }}</text> <text class="remark">{{ props.remark }}</text>

      <div class="footer">

        <view class="tags">

          <text class="tag" v-for="tag in tags" :key="tag">{{ tag }}</text>

        </view>

        <text class="price">&yen; {{ props.price }}</text>

      </div>

    </view>

  </view>

    

const { home_active_tag } = storeToRefs(useGlobalStore());

页面区域



 <view class="content">

    <FoodCard

      v-for="_package in list.dishes"

      @click="goShopByFood(_package)"

      :id="_package.id"

      :name="_package.name"

      :image="_package.image"

      :tags="_package.tags"

      :price="_package.price"

      :shop_name="_package.shop_name"

      :shop_id="_package.shop_id"

      :key="_package.id"

    ></FoodCard>

    <image

      class="card"

      @click="goMore"

      :tabindex="home_active_tag === 'more' ? 1 : 0"

      style="width: 29.375vw; height: 25.9375vw"

      src="/static/home/more.png"

      mode="aspectFill"

    />

  </view>

const goShopByFood = async (row: Record<string, any>) => {

  useGlobalStore().home_active_tag = 'foodcard' + row.id;

  uni.navigateTo({

    url: `/pages/shop/index?shop_id=${row.shop_id}`,

    animationDuration: 500,

    animationType: 'zoom-fade-out'

  });

};

如果，要设置启动默认焦点 id和index可默认设置，推荐启动第一个焦点组用index,它可以确定

  <view class="active">

    <image

      v-for="(active, i) in list.active"

      :key="active.id"

      @click="goActive(active, i)"

      :tabindex="home_active_tag === 'active' + i ? 1 : 0"

      :src="`${VITE_URL}${active.image}`"

      data-index="0"

      fade-show

      lazy-load

      mode="aspectFill"

      class="card"

    ></image>

  </view>



import { defineStore } from 'pinia';

export const useGlobalStore = defineStore('global', {

  state: () => ({

    home_active_tag: 'active0', //默认选择

    hot_active_tag: 'hot0',

    dish_active_tag: 'dish0'

  })

});

对于多层级的，要注意销毁，在前往之前设置默认焦点

const goHot = (index: number) => {

  useGlobalStore().home_active_tag = 'hotcard' + index;

  useGlobalStore().hot_active_tag = 'hot0';

  uni.navigateTo({ url: `/pages/hot/index?index=${index}`, animationDuration: 500, animationType: 'zoom-fade-out' });

};

五、如何启用wgt和apk两种方式的升级

pages.json

{

  "path": "components/update/index",

  "style": {

    "disableScroll": true,

    "backgroundColor": "#0068d0",

    "app-plus": {

      "backgroundColorTop": "transparent",

      "background": "transparent",

      "titleNView": false,

      "scrollIndicator": false,

      "popGesture": "none",

      "animationType": "fade-in",

      "animationDuration": 200

    }

  }

}

组件

<template>

  <view class="update">

    <view class="content">

      <view class="content-top">

        <text class="content-top-text">发现版本</text>

        <image class="content-top" style="top: 0" width="100%" height="100%" src="@/static/bg_top.png"> </image>

      </view>

      <text class="message"> {{ message }} </text>

      <view class="progress-box">

        <progress

          class="progress"

          border-radius="35"

          :percent="progress.progress"

          activeColor="#3DA7FF"

          show-info

          stroke-width="10"

        />

        <view class="progress-text">

          <text>安装包正在下载,请稍后，系统会自动重启</text>

          <text>{{ progress.totalBytesWritten }}MB/{{ progress.totalBytesExpectedToWrite }}MB</text>

        </view>

      </view>

    </view>

  </view>

</template>

<script setup lang="ts">

import { onLoad } from '@dcloudio/uni-app';

import { reactive, ref } from 'vue';

const message = ref('');

const progress = reactive({ progress: 0, totalBytesExpectedToWrite: '0', totalBytesWritten: '0' });

onLoad((query: any) => {

  message.value = query.content;

  const downloadTask = uni.downloadFile({

    url: `${import.meta.env.VITE_URL}/${query.url}`,

    success(downloadResult) {

      plus.runtime.install(

        downloadResult.tempFilePath,

        { force: false },

        () => {

          plus.runtime.restart();

        },

        e => {}

      );

    }

  });

  downloadTask.onProgressUpdate(res => {

    progress.progress = res.progress;

    progress.totalBytesExpectedToWrite = (res.totalBytesExpectedToWrite / Math.pow(1024, 2)).toFixed(2);

    progress.totalBytesWritten = (res.totalBytesWritten / Math.pow(1024, 2)).toFixed(2);

  });

});

</script>

<style lang="less">

page {

  background: transparent;

  .update {

    /* #ifndef APP-NVUE */

    display: flex; /* #endif */

    justify-content: center;

    align-items: center;

    position: fixed;

    left: 0;

    top: 0;

    right: 0;

    bottom: 0;

    background-color: rgba(0, 0, 0, 0.65);

    .content {

      position: relative;

      top: 0;

      width: 50vw;

      height: 50vh;

      background-color: #fff;

      box-sizing: border-box;

      padding: 0 50rpx;

      font-family: Source Han Sans CN;

      border-radius: 2vw;

      .content-top {

        position: absolute;

        top: -5vw;

        left: 0;

        image {

          width: 50vw;

          height: 30vh;

        }

        .content-top-text {

          width: 50vw;

          top: 6.6vw;

          left: 3vw;

          font-size: 3.8vw;

          font-weight: bold;

          color: #f8f8fa;

          position: absolute;

          z-index: 1;

        }

      }

    }

    .message {

      position: absolute;

      top: 15vw;

      font-size: 2.5vw;

    }

    .progress-box {

      position: absolute;

      width: 45vw;

      top: 20vw;

      .progress {

        width: 90%;

        border-radius: 35px;

      }

      .progress-text {

        margin-top: 1vw;

        font-size: 1.5vw;

      }

    }

  }

}

</style>

App.vue

import { onLaunch } from '@dcloudio/uni-app';

import { useRequest } from './hooks/useRequest';

import dayjs from 'dayjs'; onLaunch(() => {

    // #ifdef APP-PLUS

    plus.runtime.getProperty('', async app => { const res: any = await useRequest('GET', '/api/tv/app'); if (res.code === 2000 && res.row.version > (app.version as string)) { uni.navigateTo({ url: `/components/update/index?url=${res.row.url}&type=${res.row.type}&content=${res.row.content}`, fail: err => { console.error('更新弹框跳转失败', err); } }); } });

    // #endif

});

如果要获取启动参数

plus.android.importClass('android.content.Intent');

const MainActivity = plus.android.runtimeMainActivity();

const Intent = MainActivity.getIntent();

const roomCode = Intent.getStringExtra('roomCode');

if (roomCode) {

  uni.setStorageSync('roomCode', roomCode);

} else if (!uni.getStorageSync('roomCode') && !roomCode) {

  uni.setStorageSync('roomCode', '8888');

}

最近逛github的时候发现了一个非常好用的轻量工具库，Fuse.js，支持模糊搜索。感觉还是非常好用的，所以有了此篇博客，这篇文章主要是介绍Fuse的使用，同样，我对这个开源项目的实现也非常感兴趣。后续会出一篇Fuse源码解析的文章来分析其实现原理。

Fuse.js是什么？

强大、轻量级的模糊搜索库，没有任何依赖关系。

什么是模糊搜索？

一般来说，模糊搜索（更正式的名称是近似字符串匹配）是查找与给定模式近似相等（而不是完全相等）的字符串的技术。

通常我们项目中的的模糊搜索大多数情况下有几种方案可用：

• 前端工程通过正则表达式或者字符串匹配来实现


• 调用后端接口去匹配搜索


• 使用搜索引擎如：ElasticSearch或Algolia等

但是这些方案都有各自的缺陷，比如正则表达式和字符串匹配的效率较低，且无法处理复杂的搜索需求，而调用后端接口和搜索引擎虽然效率高，但是需要额外的服务器资源，且需要维护一套搜索引擎。

所以，Fuse.js的出现就是为了解决这些问题，它是一个轻量级的模糊搜索库，没有依赖关系，支持复杂的搜索需求，且效率高，当然Fuse并不适用于所有场景。

Fuse.js的使用场景

它可能不适用于所有情况，但根据您的搜索要求，它可能是最理想的。例如：

• 当您想要对小型到中等大型数据集进行客户端模糊搜索时


• 当您无法证明设置专用后端只是为了处理搜索时


• ElasticSearch 或 Algolia 虽然都是很棒的服务，但对于您的特定用例来说可能有些过度

Fuse.js的使用

安装

Fuse支持多种安装方式

NPM

npm install fuse.js

Yarn

yarn add fuse.js

CDN 引入

<script src="https://cdn.jsdelivr.net/npm/fuse.js@7.0.0">script>

引入

ES6 模块语法

import Fuse from 'fuse.js'

CommonJS 语法

const Fuse = require('fuse.js')

Tips: 使用npm或者yarn引入，支持两种模块语法引入，如果是使用cdn引入，那么Fuse将被注册为全局变量。直接使用即可

使用

以下是官网一个最简单的例子，只要简单的构造new Fuse对象，就能模糊搜索匹配到你想要的结果

// 1. List of items to search in

const books = [

  {

    title: "Old Man's War",

    author: {

      firstName: 'John',

      lastName: 'Scalzi'

    }

  },

  {

    title: 'The Lock Artist',

    author: {

      firstName: 'Steve',

      lastName: 'Hamilton'

    }

  }

]



// 2. Set up the Fuse instance

const fuse = new Fuse(books, {

  keys: ['title', 'author.firstName']

})



// 3. Now search!

fuse.search('jon')



// Output:

// [

//   {

//     item: {

//       title: "Old Man's War",

//       author: {

//         firstName: 'John',

//         lastName: 'Scalzi'

//       }

//     },

//     refIndex: 0

//   }

// ]

从上述代码中可以看到我们要通过Fuse 对books的这个数组进行模糊搜索，构建的Fuse对象中，模糊搜索的key定义为['title', 'author.firstName']，支持对title及author.firstName这两个字段进行搜索。然后执行fuse的search API就能过滤出我们的期望结果。整体代码还是非常简单的。

高级配置

Demo示例只是提供了一个基础版本的模糊搜索。如果用户想获得更灵活的搜索能力，比如搜索结果排序、权重控制、搜索结果高亮等，那么就需要对Fuse进行一些高级配置。

Fuse的所有配置都是通过new Fuse时传入的参数来配置的，下面列举一些常用的配置项：

    const options = {

            keys: ['title', 'author'], // 指定搜索key值，可多选

            isCaseSensitive: false, //是否区分大小写 默认为false

            includeScore: false, //结果集中是否展示匹配项的分数字段， 分数越大代表匹配程度越低，区间值为0-1,注意：当此项为true时，会返回完整的结果集，只不过每一项中携带了score分数字段

            includeMatches: false, //匹配项是否应包含在结果中。当时true，结果的每条记录都包含匹配项的索引。这个通常我们用来对搜索内容做高亮处理

            threshold: 0.6, // 阈值控制匹配的敏感度,默认值为0.6，如果要完全匹配这里要设置为0

            shouldSort: true, // 是否对结果进行排序

            location: 0, // 匹配的位置，0 表示开头匹配

            distance: 100, // 搜索的最大距离

            minMatchCharLength: 2, // 最小匹配字符长度

    };

出了上述常用的一些配置项之外，Fuse还支持更高阶模糊搜索，如权重搜索，嵌套搜索，运算符拓展搜索，具体高阶用法可以参考官方文档。
Fuse的主要实现原理是通过改写Bitap 算法(近似字符串匹配)算法的内部实现来支撑其模糊搜索的算法依据，后续会出一篇文章看一下作者源码的算法实现。

总结

Fuse的文章到此就结束了，你没看错就这么一点介绍就基本能支撑我们在项目中的应用，谢谢阅读，如果哪里有不对的地方请评论博主，会及时进行改正。

背景

最近更换了 windows系统的电脑， git clone 项目的时候会连接超时的错误，不管我怎么把环境变量放到终端里尝试走代理都无果，于是开始了排查

以下命令是基于 git bash 终端使用的

检测问题

通过 ssh -T git@github.com 命令查看，会报如下错误：

ssh: connect to host github.com port 22: : Connection timed out

思索了一下，难道是端口的问题吗， 于是从 overflow 上找到回答：

修改 ~/.ssh/config 路径下的内容，增加如下

Host github.com

 Hostname ssh.github.com

 Port 443

这段配置实际上是让 github.com 走 443 端口去执行，评论上有些说 22端口被占用，某些路由器或者其他程序会占用它，想了一下有道理，于是使用 vim ~/.ssh/config 编辑加上，结果...

ssh: connect to host github.com port 443: : Connection timed out

正当我苦苦思索，为什么 ping github.com 超时的时候，脑子里突然回忆起那道久违的八股文面试题： “url输入网址到浏览器上会发生什么"，突然顿悟：是不是DNS解析出了问题，找不到服务器地址？

网上学到一行命令，可以在终端里看DNS服务器的域名解析

nslookup baidu.com

先执行一下 baidu.com 的，得到如下：

Server:		119.6.6.6

Address:	119.6.6.6#53



Non-authoritative answer:

Name:	baidu.com

Address: 110.242.68.66

Name:	baidu.com

Address: 39.156.66.10

再执行一下 nslookup github.com ，果然发现不对劲了：

Name:	github.com

Address: 127.0.0.1

返回了 127.0.0.1，这不对啊，笔者可是读过书的，这是本地的 IP 地址啊，原来是这一步出了问题..

解决问题

大部分同学应该都改过本地的 DNS 域名映射文件，这也是上面那道八股文题中回答的知识点之一，我们打开资源管理器输入一下路径改一下：

C:\Windows\System32\drivers\etc\hosts

MacOs的同学可以在终端使用 sudo vi /etc/hosts 命令修改

在下面加上下面这一行， 其中 140.82.113.4 是 github 的服务器地址，添加后就可以走本地的域名映射了

140.82.113.4 github.com

保存之后，就可以不使用代理，快乐访问 github.com 了，笔者顺利的完成了梦想第一步： git clone

结语

我是饮东，欢迎点赞关注，我们江湖再会

大家好，我是G探险者。

项目里，因为我使用了Lombok插件，然后代码走查的时候被领导点名了。

我心想，这么好用的插件，为啥不推广呢，整天写那些烦人的setter，getter方法就不嫌烦么？

领导既然不让用，自然有他的道理。

于是我查了一番关于lombok的一些绯闻。就有了这篇文章。

首先呢，Lombok 是一个在 Java 项目中广泛使用的库，旨在通过注解自动生成代码，如 getter 和 setter 方法，以减少重复代码并提高开发效率。然而，Lombok 的使用也带来了一些挑战和争议，特别是关于代码的可读性和与 Java Bean 规范的兼容性。

Lombok 基本使用

示例代码

不使用 Lombok:

public class User {

    private String name;

    private int age;



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    // 其他 getter 和 setter

}

使用 Lombok:

import lombok.Data;



@Data

public class User {

    private String name;

    private int age;

    // 无需显式编写 getter 和 setter

}

Lombok 的争议

下面我就列举一个例子进行说明。

属性命名的例子

假设有这么一个属性，aName;

标准 Java Bean 规范下：

• 属性 aName 的setter getter 方法应为 setaName() getaName()。


• 但是 Lombok 可能生成 getAName()。

这是因为Lombok 在生成getter和setter方法时，将属性名的首字母也大写，即使它是小写的。所以对于aName属性，Lombok生成的方法可能是getAName()和setAName()。

在处理JSON到Java对象的映射时，JSON解析库（如Jackson或Gson）会尝试根据Java Bean规范匹配JSON键和Java对象的属性。它通常期望属性名的首字母在getter和setter方法中是小写的。因此，如果JSON键为"aName"，解析库会寻找setaName()方法。

所以，当你使用Lombok的@Data注解，且Lombok生成的setter方法为setAName()时，JSON解析库可能找不到匹配的方法来设置aName属性，因为它寻找的是setaName()。

这种差异可能在 JSON 到 Java 对象的映射中引起问题。

Java Bean 命名规范

根据 Java Bean 规范，属性名应遵循驼峰式命名法：

• 单个单词的属性名应全部小写。


• 多个单词组成的属性名每个单词的首字母通常大写。

结论

Lombok 是一个有用的工具，可以提高编码效率并减少冗余代码。但是，在使用它时，团队需要考虑其对代码可读性、维护性和与 Java Bean 规范的兼容性。在决定是否使用 Lombok 时，项目的具体需求和团队的偏好应该是主要的考虑因素。

使用JWT进行用户认证和授权，而Session在一定程度上起到了辅助作用。
让我们详细讨论JWT和Session在这种结合模式中的各自作用以及为什么需要Session。

JWT的作用

Session的作用

为什么需要创建Session

尽管JWT可以在无状态环境中使用，但Session的引入带来了以下好处：

结合JWT和Session的优势

结合使用JWT和Session，可以同时利用两者的优点，实现安全性和扩展性的平衡：

代码示例

以下是一个简化的代码示例，展示了如何在用户登录时创建JWT和Session：

java

Copy code

public LoginResponse login(String username, String password) throws AuthException {

    // 验证用户名和密码

    User user = userService.authenticate(username, password);

    if (user == null) {

        throw new AuthException("Invalid username or password");

    }

    

    // 生成JWT Token

    String token = createJwt(user.getId(), user.getRoles());

    

    // 创建会话

    sessionManagerApi.createSession(token, user);

    

    // 返回Token

    return new LoginResponse(token);

}



public void createSession(String token, User user) {

    LoginUser loginUser = new LoginUser();

    loginUser.setToken(token);

    loginUser.setUserId(user.getId());

    loginUser.setRoles(user.getRoles());

    

    sessionManagerApi.saveSession(token, loginUser);

}

在请求验证时，首先验证JWT的有效性，然后检查Session中是否存在对应的会话：

java

Copy code

@Override

public DefaultJwtPayload validateToken(String token) throws AuthException {

    try {

        // 1. 先校验jwt token本身是否有问题

        JwtContext.me().validateTokenWithException(token);



        // 2. 获取jwt的payload

        DefaultJwtPayload defaultPayload = JwtContext.me().getDefaultPayload(token);



        // 3. 如果是7天免登陆，则不校验session过期

        if (defaultPayload.getRememberMe()) {

            return defaultPayload;

        }



        // 4. 判断session里是否有这个token

        LoginUser session = sessionManagerApi.getSession(token);

        if (session == null) {

            throw new AuthException(AUTH_EXPIRED_ERROR);

        }



        return defaultPayload;

    } catch (JwtException jwtException) {

        if (JwtExceptionEnum.JWT_EXPIRED_ERROR.getErrorCode().equals(jwtException.getErrorCode())) {

            throw new AuthException(AUTH_EXPIRED_ERROR);

        } else {

            throw new AuthException(TOKEN_PARSE_ERROR);

        }

    } catch (io.jsonwebtoken.JwtException jwtSelfException) {

        throw new AuthException(TOKEN_PARSE_ERROR);

    }

}

总结

在这个场景中，JWT用于无状态的用户认证，提供便捷和扩展性；Session作为辅助，提供额外的安全性和状态管理。通过这种结合，可以充分利用两者的优点，确保系统既具备高扩展性，又能提供细致的安全控制。

最近维护了将近的一年的微信小程序（某知名企业），突然提出要兼容折叠屏，这款小程序主要功能一些图表汇总展示，也就是专门给一些领导用的，也不知道为啥领导们为啥突然喜欢用折叠屏手机了，一句话需求，苦的还是咱们程序员，但没办法，谁让甲方是爸爸呢，硬着头皮改吧，好在最后解决了，因为是甲方内部使用的小程序，这里不便贴图，但有官方案例图片，以供参考

查看了微信官网
大屏适配
响应显示区域变化

启用大屏模式

从小程序基础库版本 2.21.3 开始，在 Windows、Mac、车机、安卓 WMPF 等大屏设备上运行的小程序可以支持大屏模式。可参考小程序大屏适配指南。方法是：在 app.json 中添加 "resizable": true

看到这里我心里窃喜，就加个配置完事了？这也太简单了，但后面证明我想简单了，
主要有两大问题：

• 1 尺寸不同的情况下内容展示效果兼容问题


• 2 预览版和体验版 大屏模式冷启动会生效，但热启动 和 菜单中点击重新进入小程、授权操作，会失效变成窄屏

解决尺寸问题

因为css的长度单位大部分用的 rpx，窄屏和宽屏展示差异出入较大，别说客户不认，自己这关就过不了，简直都不忍直视，整个乱成一片，尤其登录页，用了定位，更是乱上加乱。

随后参考了官方的文档 小程序大屏适配指南和自适应布局，方案对于微信小程序原生开发是可行的，但这个项目用的 uni-app开发的，虽然uni-app 也有对应的响应式布局组件，再加上我是个比较爱偷懒的人（甲方给的工期事件也有限制），不可能花大量时间把所有也页面重新写一遍布局，这是不现实的。

于是又转战到uni-app官网寻找解决方案 uni-app宽屏适配指南

内容缩放拉伸的处理 这一段中提出了两个策略

• 1.局部拉伸：页面内容划分为固定区域和长宽动态适配区域，固定区域使用固定的px单位约定宽高，长宽适配区域则使用flex自动适配。当屏幕大小变化时，固定区域不变，而长宽适配区域跟着变化


• 2.等比缩放：根据页面屏幕宽度缩放。rpx其实属于这种类型。在宽屏上，rpx变大，窄屏上rpx变小。

随后看到这句话特别符合我的需求，哈哈 省事 省事 省事

策略2省事，设计师按750px屏宽出图，程序员直接按rpx写代码即可。但策略2的实际效果不如策略1好。程序员使用策略1，分析下界面，设定好局部拉伸区域，这样可以有更好的用户体验

具体实现

1.配置 pages.json 的 globeStyle

{

  "globalStyle": {

    "rpxCalcMaxDeviceWidth": 1200, // rpx 计算所支持的最大设备宽度，单位 px，默认值为 960

    "rpxCalcBaseDeviceWidth": 375, // rpx 计算使用的基准设备宽度，设备实际宽度超出 rpx 计算所支持的最大设备宽度时将按基准宽度计算，单位 px，默认值为 375

    "rpxCalcIncludeWidth": 750 // rpx 计算特殊处理的值，始终按实际的设备宽度计算，单位 rpx，默认值为 750

  },

}

2.单位兼容

还有一点官方也提出来了很重要，那就很多时候 会把宽度750rpx 当成100% 使用，这在宽屏的设备上就会有问题， uniapp给了两种解决方案

• 750rpx 改为100%


• 另一种是配置rpxCalcIncludeWidth，设置某个特定数值不受rpxCalcMaxDeviceWidth约束

想要用局部拉伸：页面内容划分为固定区域和长宽动态适配区域”的策略，单位必须用px

添加脚本

项目根目录新增文件 postcss.config.js 内容如下。则在编译时，编译器会自动转换rpx单位为px。

// postcss.config.js



const path = require('path')

module.exports = {

  parser: 'postcss-comment',

  plugins: {

    'postcss-import': {

      resolve(id, basedir, importOptions) {

        if (id.startsWith('~@/')) {

          return path.resolve(process.env.UNI_INPUT_DIR, id.substr(3))

        } else if (id.startsWith('@/')) {

          return path.resolve(process.env.UNI_INPUT_DIR, id.substr(2))

        } else if (id.startsWith('/') && !id.startsWith('//')) {

          return path.resolve(process.env.UNI_INPUT_DIR, id.substr(1))

        }

        return id

      }

    },

    'autoprefixer': {

      overrideBrowserslist: ["Android >= 4", "ios >= 8"],

      remove: process.env.UNI_PLATFORM !== 'h5'

    },

    // 借助postcss-px-to-viewport插件，实现rpx转px，文档：https://github.com/evrone/postcss-px-to-viewport/blob/master/README_CN.md

    // 以下配置，可以将rpx转换为1/2的px，如20rpx=10px，如果要调整比例，可以调整 viewportWidth 来实现

    'postcss-px-to-viewport': {

      unitToConvert: 'rpx',

      viewportWidth: 200,

      unitPrecision: 5,

      propList: ['*'],

      viewportUnit: 'px',

      fontViewportUnit: 'px',

      selectorBlackList: [],

      minPixelValue: 1,

      mediaQuery: false,

      replace: true,

      exclude: undefined,

      include: undefined,

      landscape: false

    },

    '@dcloudio/vue-cli-plugin-uni/packages/postcss': {}

  }

}

大屏模式失效问题

下面重头戏来了，这期间经历 蜿蜒曲折 ，到头来发现都是无用功，我自己都有被wx蠢到发笑，唉，

样式问题解决后 开始着重钻研 大屏失效的问题，但看了官方的多端适配示例demo，人家的就是好的，那就应该有解决办法，于是转战github地址 下项目，谁知这项目暗藏机关，各种报错，让你跑不起来。。。。，让我一度怀疑腾讯也这么拉跨

还好issues 区一位大神有解决办法 感兴趣的老铁可以去瞅瞅

另外 微信小程序开发工具需要取消这两项，最后当项目跑起来后我还挺开心，模拟器上没有问题，但用真机预览的时候我啥眼了，还是窄屏，偶尔可以大屏，后面发现 冷启动是大屏，热启动和点击右上角菜单中的重新进入小程序按钮都会自己变成窄屏幕

这是官方的项目啊，为啥人家的可以，我本地跑起来却不可以，让我一度怀疑这里有内幕，经过几轮测试还是不行，于是乎，我开始了各种询问查资料，社区、私聊、评论、github issues，最后甚至 统计出来了 多端适配示例demo 开发者的邮箱 挨个发了邮件，但都结果无一例外，全部石沉大海

结果就是，没有办法了，想看看是不是只有预览和体验版有问题，后面发布到正式版后，再看居然没问题了，就是这么神奇，也是无语！！！！ 原来做了这么多无用功。。。。

1. 通用组件（表单搜索+表格展示+分页器）

在项目当中我们总会遇到这样的页面：页面顶部是一个表单筛选项，下面是一个表格展示数据。表格下方是一个分页器，这样的页面在我们的后台管理系统中经常所遇到，有时候可能不止一个页面，好几个页面的结构都是这种。如图：

本人记得，在react中的高级组件库中有这么一个组件，就实现了这么一个效果。就拿这个页面来说我们实现一下组件封装的思想：1.首先把每个页面的公共部分抽出来，比如标题等，用props或者插槽的形式传入到组件中进行展示 2. 可以里面数据的双向绑定实现跟新的效果 3. 设置自定义函数传递给父组件要做上面事情

1.将公共的部分抽离出来

TableContainer组件

<template>

    <div class="container">

      <slot name="navbar"></slot>

      <div class="box-detail">

        <div class="detail-box">

          <div class="box-left">

            <div class="left-bottom">

              <div class="title-bottom">{{ title }}</div>

              <div class="note">  

                <div class="note-detail">

                  <slot name="table"></slot>

                </div>

              </div>

            </div>

          </div>

        </div>

      </div>

      <el-backtop style="width: 3.75rem; height: 3.75rem" :bottom="10" :right="5">

        <div

          style="

             {

              width: 5.75rem;

              flex-shrink: 0;

              border-radius: 2.38rem;

              background: #fff;

              box-shadow: 0 0.19rem 1rem 0 #2b4aff14;

            }

          "

        >

          <i class="el-icon-arrow-up" style="color: #6e6f74"></i>

        </div>

      </el-backtop>

    </div>

  </template>

这里的话利用了具名插槽插入了navbar、table组件，title通过props的属性传入到子组件当中。进行展示，

父组件

    <TableContainer title="资源审核">

        <template v-slot:navbar>

            <my-affix :offset="0">

                <Navbar/>

            </my-affix>

        </template>

        <template v-slot:table>

            <SourceAuditTable/>

        </template>

    </TableContainer>

当然这是一个非常非常简单的组件封装案例

接下来我们看一个高级一点的组件封装

父组件

<template>

  <div>

    <hr>

    <HelloWorld :page.sync="page" :limit.sync="limit" />

  </div>

</template>



<script>

import HelloWorld from './components/HelloWorld.vue';

export default {

  data() {

    return {

      page: 1,

      limit: 5

    }

  },

  components: {

    HelloWorld

  },





}

</script>

父组件传递给子组件各种必要的属性：total（总共多少条数据）、page(当前多少页)、limit（每页多少条数据）、pageSizes（选择每页大小数组）

子组件

<template>

  <el-pagination :current-page.sync="currentPage" :page-size.sync="pageSize" :total="20" />

</template>



<script>

export default {

  name: 'HelloWorld',



  props: {

    page: {

      default: 1

    },

    limit: {

      default: 5

    },

  },

  computed: {

    currentPage: {

      get() {

        return this.page

      },

      set(val) {

        //currentPage 这里对currentPage做出来改变就会走这里

        //这边更新数据走这里

        console.log('currentPage', this.currentPage)

        this.$emit('update:page', val)

      }

    },

    pageSize: {

      get() {

        return this.limit

      },

      set(val) {

        this.$emit('update:limit', val)

      }

    }

  },

  methods: {

  }

}

</script>



<!-- Add "scoped" attribute to limit CSS to this component only -->

这里的page.sync、limit.sync目的就是为了实现数据的双向绑定，computed中监听page和limit的变化，子组件接收的数据通过computed生成的currentPage通过sync绑定到了 el-pagination中， 点击分页器的时候会改变currentPage 此时会调用set函数设置新的值，通过代码 this.$emit（update:page,value） 更新父组件中的值，实现双向的数据绑定

本文是作者在闲暇的时间随便记录一下， 若有错误请指正，多多包涵。感谢支持！