如何应对Android面试官-＞实战高级UI，用自定义View画一条锦鲤(下)

news2024/11/26 10:02:04

前言

上一章我们用自定义View绘制了一条小鱼，本章我们让这条小鱼游动起来；

涉及的知识点

infoflow 2024-02-19 10-05-04.png

小鱼的原地摆动

实现小鱼的摆动，我们可以通过属性动画 ValueAnimator 来实现，这里先简单介绍下属性动画

属性动画（ValueAnimator）

  1. ValueAnimator 没有重绘，所以需要自己调用 addUpdateListener 方法，结合 AnimatorUpdateListener 使用；
  2. 操作的对象的属性不一定要有 get set 方法；
  3. 默认插值器为 AccelerateDecelerateInterpolator；

基础用法

public void init() {
    //
    ...
    // 
    
    // 动画周期
    ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, 1f);
    // 动画时长
    valueAnimator.setDuration(1000);
    // 重复模式，重新开始
    valueAnimator.setRepeatMode(ValueAnimator.RESTART);
    // 重复次数 无线循环
    valueAnimator.setRepeatCount(ValueAnimator.INFINITE);
    valueAnimator.setInterpolator(new LinearInterpolator());
    valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animator) {
            animatedValue = animator.getAnimatedValue();
            invalidateSelef();
        }
    });
    valueAnimator.start();
}

鱼头的摆动

上一章节我们有讲到，使用

// 鱼的主要朝向角度
private float fishMainAngle = 0;

来控制鱼的朝向，那么我们就可以通过它来让我们的鱼头摆动起来，假设我们让鱼头摆动 10 度左右，只需要让 fishMainAngle * animatedValue * 10 就可以了，我们来运行看下效果

@Override
public void draw(@NonNull Canvas canvas) {
    float fishAngle = fishMainAngle + animatedValue * 10;
}

SVID_20240219_103258_1.gif

可以看到，鱼头已经摆动了起来，但是整体还不符合我们的预期，我们接着来调整鱼尾的摆动；

鱼尾的摆动

实现鱼尾的摆动，思路和鱼头一样，只需要让鱼尾的角度改变就行;

/**
 * 画节肢
 *
 * @param canvas               画布
 * @param bottomCenterPoint    大圆中心点坐标
 * @param findMiddleCircleLength 中圆长度
 * @param bigCircleRadius 大圆半径
 * @param middleCircleRadius 中圆半径
 * @param fishAngle 角度
 */
private PointF makeSegment(Canvas canvas, PointF bottomCenterPoint, float findMiddleCircleLength,
                           float bigCircleRadius, float middleCircleRadius, float fishAngle, boolean hasBigCircle) {

    float segmentAngle = fishAngle + animatedValue * 20;
    // 计算中圆坐标(梯形上底圆的圆心)
    PointF upperCenterPoint = calculatePoint(bottomCenterPoint, findMiddleCircleLength, fishAngle - 180);
    // 计算梯形的四个点
    PointF bottomLeftPoint = calculatePoint(bottomCenterPoint, bigCircleRadius, segmentAngle + 90);
    PointF bottomRightPoint = calculatePoint(bottomCenterPoint, bigCircleRadius, segmentAngle - 90);
    PointF upperLeftPoint = calculatePoint(upperCenterPoint, middleCircleRadius, segmentAngle + 90);
    PointF upperRightPoint = calculatePoint(upperCenterPoint, middleCircleRadius, segmentAngle - 90);
    if (hasBigCircle) {
        // 画大圆
        canvas.drawCircle(bottomCenterPoint.x, bottomCenterPoint.y, bigCircleRadius, mPaint);
    }
    // 画小圆
    canvas.drawCircle(upperCenterPoint.x, upperCenterPoint.y, middleCircleRadius, mPaint);
    // 画梯形
    mPath.reset();
    mPath.moveTo(upperLeftPoint.x, upperLeftPoint.y);
    mPath.lineTo(upperRightPoint.x, upperRightPoint.y);
    mPath.lineTo(bottomRightPoint.x, bottomRightPoint.y);
    mPath.lineTo(bottomLeftPoint.x, bottomLeftPoint.y);
    canvas.drawPath(mPath, mPaint);
    return upperCenterPoint;
}

我们运行看下效果：

SVID_20240219_104208_1.gif

可以看到，鱼尾也能摆动了起来，但是如果我们想让鱼头和鱼尾不同的频率，显然现有的一个属性动画还是不够的，那么我们如何实现让鱼头和鱼尾不同的频率呢？

我们可以使用两个 ValueAnimator 来分别实现鱼头和鱼尾的摆动，但是我们能使用一个 ValueAnimator 来实现鱼头和鱼尾不同频率的摆动吗？让我们来一探究竟；

鱼头鱼尾不同频率的摆动

上一章我们讲了正弦函数，正弦函数的一个周期是360，如果我们的属性动画的周期是 ValueAnimator.ofFloat(0，3600) 那么就相当于是1s 10个周期，如果我们给 animatedValue 取一个正弦函数，并且让它的周期发生改变，那么我们的鱼头和鱼尾的摆动频率就不一样了；

sin(animatedValue) ==> animatedValue 取值是（0-360） 1s执行1次

sin(animatedValue * 2) ==> animatedValue 取值是（0-360）1s执行2次

也就是说 sin(0-360) 的取值是 -1 ~ 1 这样的一个范围，那么我们的鱼头摆动的角度就是 -10 ~ 10 这样的一个范围，鱼头就实现了从 -10 到 10 的一个左右的摆动了;

也就是说 sin((0-360)X2) 的取值是 -1 ~ 1 & -1 ~ 1 这样的一个范围，那么我们的鱼头摆动的角度就是 -10 ~ 10 这样的一个范围，鱼头就实现了从 -10 到 10 的一个左右的摆动了，并且1s内摆动了2次;

同理，鱼尾也是这样的一个范围，我们只需要调整这个sin(x)的值，让它的结果值不一样，那么摆动的频率也就不一样了；

节肢是分为节肢1和节肢2，节肢1和节肢2的摆动频率也不一样，并且节肢1的摆动，带动了节肢2的摆动，根据正余弦函数 sin 和 cos 正好相差 90，节肢1和节肢2可以采用 sin 和 cos 来实现方向和频率上的变化，具体实现如下：

// 动画周期
ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, 360f);

@Override
public void draw(@NonNull Canvas canvas) {
    float fishAngle = (float) (fishMainAngle + Math.sin(Math.toRadians(animatedValue)) * 10);
}

节肢1和节肢2的变化

/**
 * 画节肢
 *
 * @param canvas               画布
 * @param bottomCenterPoint    大圆中心点坐标
 * @param findMiddleCircleLength 中圆长度
 * @param bigCircleRadius 大圆半径
 * @param middleCircleRadius 中圆半径
 * @param fishAngle 角度
 */
private PointF makeSegment(Canvas canvas, PointF bottomCenterPoint, float findMiddleCircleLength,
                           float bigCircleRadius, float middleCircleRadius, float fishAngle, boolean hasBigCircle) {

    float segmentAngle;
    if (hasBigCircle) {
        segmentAngle = (float) (fishAngle + Math.cos(Math.toRadians(animatedValue * 1.5)) * 15);
    } else {
        segmentAngle = (float) (fishAngle + Math.sin(Math.toRadians(animatedValue * 1.5)) * 20);
    }
    // 计算中圆坐标(梯形上底圆的圆心)
    PointF upperCenterPoint = calculatePoint(bottomCenterPoint, findMiddleCircleLength, segmentAngle - 180);
    // 计算梯形的四个点
    PointF bottomLeftPoint = calculatePoint(bottomCenterPoint, bigCircleRadius, segmentAngle + 90);
    PointF bottomRightPoint = calculatePoint(bottomCenterPoint, bigCircleRadius, segmentAngle - 90);
    PointF upperLeftPoint = calculatePoint(upperCenterPoint, middleCircleRadius, segmentAngle + 90);
    PointF upperRightPoint = calculatePoint(upperCenterPoint, middleCircleRadius, segmentAngle - 90);
    if (hasBigCircle) {
        // 画大圆
        canvas.drawCircle(bottomCenterPoint.x, bottomCenterPoint.y, bigCircleRadius, mPaint);
    }
    // 画小圆
    canvas.drawCircle(upperCenterPoint.x, upperCenterPoint.y, middleCircleRadius, mPaint);
    // 画梯形
    mPath.reset();
    mPath.moveTo(upperLeftPoint.x, upperLeftPoint.y);
    mPath.lineTo(upperRightPoint.x, upperRightPoint.y);
    mPath.lineTo(bottomRightPoint.x, bottomRightPoint.y);
    mPath.lineTo(bottomLeftPoint.x, bottomLeftPoint.y);
    canvas.drawPath(mPath, mPaint);
    return upperCenterPoint;
}

我们运行看下效果：

SVID_20240219_111823_1.gif

可以看到 鱼头、鱼尾不同的摆动频率；

三角形鱼尾的摆动

接下来我们来让三角形也摆动起来，三角形的摆动频率是和节肢2的摆动频率一样的，所以我们可以让这两个值保持一致来看下效果

private void makeTriangle(Canvas canvas, PointF startPoint, float findTriangleLength,
                          float bigCircleRadius, float fishAngle) {
    float triangleAngle = (float) (fishAngle + Math.sin(Math.toRadians(animatedValue * 1.5)) * 20);
    // 三角形底边中心点坐标
    PointF centerPoint = calculatePoint(startPoint, findTriangleLength, triangleAngle);
    // 三角形底边两点
    PointF leftPoint = calculatePoint(centerPoint, bigCircleRadius, triangleAngle + 90);
    PointF rightPoint = calculatePoint(centerPoint, bigCircleRadius, triangleAngle - 90);

    mPath.reset();
    mPath.moveTo(startPoint.x, startPoint.y);
    mPath.lineTo(leftPoint.x,  leftPoint.y);
    mPath.lineTo(rightPoint.x, rightPoint.y);
    canvas.drawPath(mPath, mPaint);
}

SVID_20240219_124315_1.gif

可以看到，三角形的尾巴也摆动了起来；但是效果一卡一卡的，我们来优化一下；首先我们来看下为什么会一卡一卡的，这个是因为动画结束之后并没有回到起点开始，这个是因为我们在频率变化的地方乘以了1.5
也就是 360 * 1.5 / 360 = 1.5，这个结果不是整数，也就是说不是 360 的整数倍，我们需要把它设置成 360 的整数倍，修改如下

ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, 720f);

720 * 1.5 / 360 = 3 是360的整数倍，我们来看下效果：

SVID_20240219_125055_1.gif

卡顿效果没有了；

小鱼的三角形尾巴旋转

这个就比较简单了，周期性的改变这个值即可

// 画三角形
float findTriangleAngle = (float) Math.abs(Math.sin(Math.toRadians(animatedValue * 1.5)) * BIG_CIRCLE_RADIUS);
makeTriangle(canvas, middlePointF, FIND_TRIANGLE_LENGTH, findTriangleAngle, fishAngle);
makeTriangle(canvas, middlePointF, FIND_TRIANGLE_LENGTH - 10,
        findTriangleAngle - 20, fishAngle);

运行看下效果：

SVID_20240219_132806_1.gif

三角形尾巴旋转了起来；

小鱼的游动

我们接下来实现小鱼的游动，想要实现小鱼的游动，我们需要把这个 Drawable 放到 ViewGroup 中，并且在这个 ViewGroup 中实现点击画一个水波纹，同时让小鱼游动过去，我们先来搭建一个简单的架子；

public class FishLayout extends RelativeLayout {

    private Paint mPaint;
    private ImageView ivFish;
    private Fish fishDrawable;


    public FishLayout(Context context) {
        this(context, null);
    }

    public FishLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public FishLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);

        init(context);
    }

    private void init(Context context) {
        // ViewGroup 默认不执行 onDraw 方法
        setWillNotDraw(false);
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setDither(true);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(8);

        ivFish = new ImageView(context);
        LayoutParams layoutParams = new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        fishDrawable = new Fish();
        ivFish.setLayoutParams(layoutParams);
        ivFish.setImageDrawable(fishDrawable);
        addView(ivFish);
    }
}

水波纹的绘制

水波纹的绘制，我们同样采用属性动画(ObjectAnimator)来实现，区别于 ValueAnimator，ObjectAnimator 在使用的过程中要求属性必须实现 get 和 set 方法；然后我们接入 canvas 的 drawCircle 方法来实现水波纹的绘制

private float touchX;
private float touchY;
private float ripple;
private int alpha;

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    mPaint.setAlpha(alpha);
    canvas.drawCircle(touchX, touchY, ripple * 150, mPaint);
    invalidate();
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    touchX = event.getX();
    touchY = event.getY();
    ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(this, "ripple", 0, 1f);
    objectAnimator.setDuration(1000);
    objectAnimator.start();
    return super.onTouchEvent(event);
}

public float getRipple() {
    return ripple;
}

public void setRipple(float ripple) {
    alpha = (int) (100 * (1 - ripple));
    this.ripple = ripple;
}

我们运行看下效果：

SVID_20240219_135332_1.gif

我们实现了点击水波纹的效果；

小鱼的移动

小鱼的游动，其实是一个三阶贝塞尔曲线，三阶贝塞尔曲线，需要四个控制点，我们这里采用鱼头圆心点，鱼的身体中心点，点击点，以及这三个点击组成的夹角的一半

infoflow 2024-02-19 14-02-33.png

也就是这四个点，我们来分别计算这四个点的坐标，然后绘制三阶贝塞尔曲线；这里我们就用到了向量夹角的计算公式

向量的夹角公式计算夹角cosAOB = (OA x OB)/(|OA|*|OB|)其中 OA x OB 是向量的数量积，计算过程如下：

OA = (Ax-Ox,Ay-Oy)

OB = (Bx-Ox,By-Oy)

OA x OB = (Ax-Ox)(Bx-Ox)+(Ay-Oy)x(By-Oy)

|OA|表示线段OA的模即OA的长度

所以实现如下：

// cosAOB
// OA*OB = (Ax-Ox)*(Bx-Ox) + (Ay-Oy)*(By-Oy)
float AOB = (A.x - O.x) * (B.x - O.x) + (A.y - O.y) * (B.y-O.y);
float OALength = (float) Math.sqrt((A.x - O.x) * (A.x - O.x) + (A.y - O.y) * (A.y - O.y));
float OBLength = (float) Math.sqrt((B.x - O.x) * (B.x - O.x) + (B.y - O.y) * (B.y - O.y));
float cosAOB = AOB / (OALength * OBLength);
// 反余弦
float angleAOB = (float) Math.toDegrees(Math.acos(cosAOB));

我们还需要决定鱼的转向，也就是说点击点在鱼的右侧，鱼头转向右边游动，点击在鱼的左侧，鱼头转向左边游动；

鱼朝哪边转向.png

也就是说：我们以AO中线为界限，分为四个区域来看

infoflow 2024-02-19 16-19-41.png

也就是 鱼的右边小于0，鱼的左边大于0，所以计算如下：

// AB连线与x轴的夹角的 tan 值 - OB连线与x轴的夹角的 tan 值
float direction = (A.y - B.y) / (A.x - B.x) - (O.y - B.y) / (O.x - B.x);
if (direction == 0) {
    if (AOB >= 0) {
        return 0f;
    } else {
        return 180f;
    }
} else {
    if (direction > 0) {
        return -angleAOB;
    } else {
        return angleAOB;
    }
}

所以我们的起始点坐标为：

// 鱼的重心，相当于ImageView的坐标
PointF fishRelativeMiddle = fishDrawable.getMiddlePoint();
// 鱼的重心，绝对坐标 -- 起始点坐标
PointF fishMiddle = new PointF(ivFish.getX() + fishRelativeMiddle.x, ivFish.getY() + fishRelativeMiddle.y);

控制点1的坐标为：

// 鱼头圆心坐标 -- 控制点1坐标
PointF headPoint = fishDrawable.getHeadPoint();
PointF fishHead = new PointF(ivFish.getX() + headPoint.x, ivFish.getY() + headPoint.y);

点击点坐标，结束点坐标：

// 点击坐标 -- 结束点坐标
PointF touch = new PointF(touchX, touchY);
float angle = includeAngle(fishMiddle, fishHead, touch) / 2;
float delta = includeAngle(fishMiddle, new PointF(fishMiddle.x + 1, fishMiddle.y), fishHead);

控制点2的坐标为：

// 控制点2的坐标
PointF controlPoint = fishDrawable.calculatePoint(fishMiddle, fishDrawable.getHEAD_RADIUS() * 1.6f, angle + delta);

三阶贝塞尔曲线绘制

Path path = new Path();
path.moveTo(fishMiddle.x - fishRelativeMiddle.x, fishMiddle.y - fishRelativeMiddle.y);
path.cubicTo(fishHead.x - fishRelativeMiddle.x, fishHead.y - fishRelativeMiddle.y,
        controlPoint.x - fishRelativeMiddle.x, controlPoint.y - fishRelativeMiddle.y,
        touchX - fishRelativeMiddle.x, touchY - fishRelativeMiddle.y);
ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(ivFish, "x", "y", path);
objectAnimator.setDuration(2000);
objectAnimator.start();

小鱼移动的完整实现如下：

private void move() {
    // 鱼的重心，相当于ImageView的坐标
    PointF fishRelativeMiddle = fishDrawable.getMiddlePoint();
    // 鱼的重心，绝对坐标 -- 起始点坐标
    PointF fishMiddle = new PointF(ivFish.getX() + fishRelativeMiddle.x, ivFish.getY() + fishRelativeMiddle.y);
    // 鱼头圆心坐标 -- 控制点1坐标
    PointF headPoint = fishDrawable.getHeadPoint();
    PointF fishHead = new PointF(ivFish.getX() + headPoint.x, ivFish.getY() + headPoint.y);
    // 点击坐标 -- 结束点坐标
    PointF touch = new PointF(touchX, touchY);
    float angle = includeAngle(fishMiddle, fishHead, touch) / 2;
    float delta = includeAngle(fishMiddle, new PointF(fishMiddle.x + 1, fishMiddle.y), fishHead);
    // 控制点2的坐标
    PointF controlPoint = fishDrawable.calculatePoint(fishMiddle, fishDrawable.getHEAD_RADIUS() * 1.6f, angle + delta);
    Path path = new Path();
    path.moveTo(fishMiddle.x - fishRelativeMiddle.x, fishMiddle.y - fishRelativeMiddle.y);
    path.cubicTo(fishHead.x - fishRelativeMiddle.x, fishHead.y - fishRelativeMiddle.y,
            controlPoint.x - fishRelativeMiddle.x, controlPoint.y - fishRelativeMiddle.y,
            touchX - fishRelativeMiddle.x, touchY - fishRelativeMiddle.y);
    ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(ivFish, "x", "y", path);
    objectAnimator.setDuration(2000);
    objectAnimator.start();
}

public float includeAngle(PointF O, PointF A, PointF B) {
    // cosAOB
    // OA*OB = (Ax-Ox)*(Bx-Ox) + (Ay-Oy)*(By-Oy)
    float AOB = (A.x - O.x) * (B.x - O.x) + (A.y - O.y) * (B.y-O.y);
    float OALength = (float) Math.sqrt((A.x - O.x) * (A.x - O.x) + (A.y - O.y) * (A.y - O.y));
    float OBLength = (float) Math.sqrt((B.x - O.x) * (B.x - O.x) + (B.y - O.y) * (B.y - O.y));
    float cosAOB = AOB / (OALength * OBLength);
    // 反余弦
    float angleAOB = (float) Math.toDegrees(Math.acos(cosAOB));
    // AB连线与x轴的夹角的 tan 值 - OB连线与x轴的夹角的 tan 值
    float direction = (A.y - B.y) / (A.x - B.x) - (O.y - B.y) / (O.x - B.x);
    if (direction == 0) {
        if (AOB >= 0) {
            return 0f;
        } else {
            return 180f;
        }
    } else {
        if (direction > 0) {
            return -angleAOB;
        } else {
            return angleAOB;
        }
    }
}

在 onTouchEvent 中调用这个 move 方法

@Override
public boolean onTouchEvent(MotionEvent event) {
    touchX = event.getX();
    touchY = event.getY();
    ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(this, "ripple", 0, 1f);
    objectAnimator.setDuration(1000);
    objectAnimator.start();

    move();
    return super.onTouchEvent(event);
}

之前设置的鱼的半径比较大，我们调小一些，方便看一屏下看运行效果

/**
 * 鱼的长度值
 */
// 绘制鱼头的半径
private float HEAD_RADIUS = 50;

我们来运行看下效果：

SVID_20240219_182339_1.gif

可以看到，我们实现了小鱼的点击移动

小鱼游动的时候，鱼尾摆动频率增加

接下来我们来实现，点击移动的时候，鱼尾的摆动频率增加，这里依然借助于属性动画

objectAnimator.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationEnd(Animator animation) {
        super.onAnimationEnd(animation);
    }

    @Override
    public void onAnimationStart(Animator animation) {
        super.onAnimationStart(animation);
    }
});

我们在游动动画开始的时候，给鱼尾的值增加一个倍数，在所有使用 animatedValue 的地方使用这个倍数即可

float fishAngle = (float) (fishMainAngle + Math.sin(Math.toRadians(animatedValue * frequence)) * 10);

float findTriangleAngle = (float) Math.abs(Math.sin(Math.toRadians(animatedValue * 1.5 * frequence)) * BIG_CIRCLE_RADIUS);

float triangleAngle = (float) (fishAngle + Math.sin(Math.toRadians(animatedValue * 1.5 * frequence)) * 20);

if (hasBigCircle) {
    segmentAngle = (float) (fishAngle + Math.cos(Math.toRadians(animatedValue * 1.5 * frequence)) * 15);
} else {
    segmentAngle = (float) (fishAngle + Math.sin(Math.toRadians(animatedValue * 1.5 * frequence)) * 20);
}

然后在我们动画开始的时候，调大这个值，动画结束的时候恢复这个值

objectAnimator.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationEnd(Animator animation) {
        super.onAnimationEnd(animation);
        fishDrawable.setFrequence(1f);
    }

    @Override
    public void onAnimationStart(Animator animation) {
        super.onAnimationStart(animation);
        fishDrawable.setFrequence(3f);
    }
});

我们运行看下效果：

SVID_20240219_183151_1.gif

可以看到在游动的时候，鱼尾的摆动频率加快了；

鱼头转向

接下来我们来实现鱼的转向，在游动的时候先转向，然后游到点击的位置；鱼头的转向其实也是一个贝塞尔曲线

图片 1.png

转向的实现其实就是鱼头的切线轨迹和游动路线轨迹重合，鱼头切线变化的角度和路径的角度保持一致，我们就能实现鱼头的转向了；

而 切线其实就是我们的 tan 值；切线值的获取需要用到系统提供的 PathMeasure；

final PathMeasure pathMeasure = new PathMeasure(path, false);
final float[] tan = new float[2];
objectAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    @Override
    public void onAnimationUpdate(ValueAnimator animation) {
        float fraction = animation.getAnimatedFraction();
        pathMeasure.getPosTan(pathMeasure.getLength() * fraction, null, tan);
        float angle = (float) Math.toDegrees(Math.atan2(-tan[1], tan[0]));
        fishDrawable.setFishMainAngle(angle);
    }
});

我们运行看下效果：

12e0e065-7315-43f7-8aec-6e81a39a9397.gif

我们实现了点击的时候鱼的转向逻辑；

好了，到这里我们就实现了开篇的时候的完整逻辑；

下一章预告

Handler 原理解析；

欢迎三连

来都来了，点个关注，点个赞吧，你的支持是我最大的动力~~~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1456856.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

生成对抗网络----GAN

生成对抗网络----GAN

系列文章目录 文章目录 系列文章目录前言一、基本构成二、应用领域三、基本原理四、如何训练GAN 前言 一、基本构成 GAN (Generative Adversarial Network) : 通过两个神经网络，即生成器（Generator）和判别器（Discriminator&#…
阅读更多...
6.s081 学习实验记录（九）lock parallelism

6.s081 学习实验记录（九）lock parallelism

文章目录 一、Memory allocator简介提示实验代码实验结果 二、Buffer cache简介提示实验代码实验结果 该实验将重构某些代码以提高并发度。 首先切换到lock分支： git fetchgit checkout lockmake clean 一、Memory allocator 简介 user/kalloctest 这个程序会对…
阅读更多...
企事业单位 | 公司办公终端、电脑文件数据\资料防泄密软件系统——防止核心数据资料外泄！

企事业单位 | 公司办公终端、电脑文件数据\资料防泄密软件系统——防止核心数据资料外泄！

天锐绿盾是一款专门设计用于防止公司文件数据泄露的软件。 PC端：https://isite.baidu.com/site/wjz012xr/2eae091d-1b97-4276-90bc-6757c5dfedee 以下是该软件的几个关键特点： 文件加密：天锐绿盾使用先进的加密技术，对存储在电脑…
阅读更多...
SpringIOC之support模块SimpleThreadScope

SpringIOC之support模块SimpleThreadScope

博主介绍：✌全网粉丝5W，全栈开发工程师，从事多年软件开发，在大厂呆过。持有软件中级、六级等证书。可提供微服务项目搭建与毕业项目实战，博主也曾写过优秀论文，查重率极低，在这方面有丰富的经验…
阅读更多...
Dubbo框架admin搭建

Dubbo框架admin搭建

Dubbo服务监控平台，dubbo-admin是图形化的服务管理界面，从服务注册中心获取所有的提供者和消费者的配置。 dubbo-admin是前后端分离的项目，前端使用Vue，后端使用springboot。因此，前端需要nodejs环境，后端需…
阅读更多...
上百份信任印记，见证我们与客户共赴的数智化征程

上百份信任印记，见证我们与客户共赴的数智化征程

回看2023，这注定是不平凡的一年！ 全国经济加快复苏，中国作为世界经济增长的压舱石，以5.2%的GDP增长成为全球经济发展的稳定力量。 国务院印发《数字中国建设整体布局规划》，从政府到央国企，从行业领头羊到…
阅读更多...
【Git】上传本地文件到Git（以Windows环境为例）

【Git】上传本地文件到Git（以Windows环境为例）

Git 的下载参考：Git 安装及配置 一、Git 上传的整体流程 1、工作区 > 本地仓库 将本地文件上传到Git，需要先上传到本地仓库，然后再上传到远程仓库。要上传文件到本地仓库，不是直接拷贝进去的，而是需要通过命令一步…
阅读更多...
LLM应用开发与落地：chroma的近似搜索问题

LLM应用开发与落地：chroma的近似搜索问题

背景 最近开始测试一个游戏客户的RAG模块，发现一个向量数据库中大家容易忽略的一个点：近邻搜索算法。一开始我们选择的是chroma作为向量数据库，因为chroma的用户接口和设计非常简单，而我偏向于简单。创建collection时设置的距离计…
阅读更多...
stable-video-diffusion 图生视频模型diffusers使用案例

stable-video-diffusion 图生视频模型diffusers使用案例

T4卡16g运行： 参考：https://huggingface.co/docs/diffusers/main/en/using-diffusers/text-img2vid 案例用的google colab T4显卡运行 安装包：pip install diffusers accelerate 代码 import torch from diffusers import StableVideoDiffusionPipeline from diffusers.uti…
阅读更多...
SPSSAU【文本分析】|我的项目

SPSSAU【文本分析】|我的项目

文本分析之我的项目 SPSSAU提供文本分析模块，其单独针对文本数据进行研究和分析使用，其包括词云分析、文本情感分析、文本聚类分析、社会网络关系分析、LDA主题分析、新词发现和我的词库等功能。使用SPSSAU进行文本分析时，涉及下述内容。分别…
阅读更多...
【刷刷刷，爽！】leetcode198. 打家劫舍

【刷刷刷，爽！】leetcode198. 打家劫舍

题目如上！ 这是一道非常非常标准的初级动规题。属于走楼梯的进阶版。所以我们尝试把他变成走楼梯。 怎么变？或者说是怎么看成走楼梯。 答案是！！！！ 看最后一个数。 往往会最有灵感。 比如示例1中[1,2,3,4]&a…
阅读更多...
docker 服务的启动命令

docker 服务的启动命令

Docker 服务的启动命令主要涉及 Docker Daemon 的启动和管理。Docker Daemon 是在后台运行的服务进程，负责管理 Docker 容器的创建、运行、停止等操作。根据你使用的操作系统，启动 Docker 服务的命令可能有所不同。 对于 Linux 系统 使用 systemctl (适…
阅读更多...
【二十四】【C++】多态

【二十四】【C++】多态

多态的基本概念 多态是一种允许使用相同的接口来访问不同的底层形式（类型）的对象的能力。C中的多态主要通过以下两种方式实现： 编译时多态（静态多态）：通过函数重载和运算符重载实现。 运行时多态&#x…
阅读更多...
基于数字双输入的超宽带Doherty功率放大器设计-从理论到ADS版图

基于数字双输入的超宽带Doherty功率放大器设计-从理论到ADS版图

基于数字双输入的超宽带Doherty功率放大器设计-从理论到ADS版图 参考论文: 高效连续型射频功率放大器研究 假期就要倒计时啦，估计是寒假假期的最后一个博客，希望各位龙年工作顺利，学业有成。 全部工程下载：基于数字双输入的超宽…
阅读更多...
机器人初识 —— 定制AI

机器人初识 —— 定制AI

一、机器人设计难点 波士顿动力设计的机器人，尤其是其人形机器人Atlas和四足机器人Spot等产品，在技术上面临多重难点： 1. **动态平衡与稳定性**：双足或四足机器人在运动时需要维持极高的动态平衡，特别是在不平坦地面…
阅读更多...
KMP算法简介以及相关例题的分析

KMP算法简介以及相关例题的分析

一.KMP算法简介 KMP 算法是 D.E.Knuth、J,H,Morris 和 V.R.Pratt 三位神人共同提出的，称之为 Knuth-Morria-Pratt 算法，简称 KMP 算法。该算法相对于 Brute-Force（暴力）算法有比较大的改进，主要是消除了主串指针的回溯…
阅读更多...
【Java面试】MongoDB

【Java面试】MongoDB

目录 1、mongodb是什么？2、mongodb特点什么是NoSQL数据库？NoSQL和RDBMS有什么区别？在哪些情况下使用和不使用NoSQL数据库？NoSQL数据库有哪些类型?启用备份故障恢复需要多久什么是master或primary什么是secondary或slave系列文章版…
阅读更多...
【Vuforia+Unity】01实现单张多张图片识别产生对应数字内容

【Vuforia+Unity】01实现单张多张图片识别产生对应数字内容

1.官网注册 Home | Engine Developer Portal 2.下载插件SDK，导入Unity 3.官网创建数据库上传图片，官网处理成数据 下载好导入Unity！ 下载好导入Unity！ 下载好导入Unity！ 下载好导入Unity！ 4.在Unity设…
阅读更多...
unity C#中的封装、继承和多态简单易懂的经典实例

unity C#中的封装、继承和多态简单易懂的经典实例

文章目录 封装 (Encapsulation)继承 (Inheritance)多态 (Polymorphism) C#中的封装、继承和多态是面向对象编程（OOP）的三大核心特性。下面分别对这三个概念进行深入解释，并通过实例来说明它们在实际开发中的应用。 封装 (Encapsulation) 实例…
阅读更多...
11. Springboot集成Dubbo3（二）示例demo

11. Springboot集成Dubbo3（二）示例demo

目录 1、前言 2、注册中心 3、快速开始 3.1、添加dubbo3依赖 3.2、dubbo3-api ​编辑 3.3、dubbo3-server 3.3.1、添加依赖 3.3.2、实现IUserService 3.3.3、添加配置文件application.properties 3.3.4、修改Application启动类 3.3.5、出错解决 3.4、dubbo3-porta…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023