rxjs 源码分析1-(fromEvent)

2023-12-18 16:58
文章标签 分析 源码 rxjs fromevent

本文主要是介绍rxjs 源码分析1-(fromEvent)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

Rxjs是使用 Observables 的响应式编程的库，它使编写异步或基于回调的代码更容易。我们现在针对Rxjs 6 来进行源码分析，分析其实现的基本原理， 我们可以根据中文文档来学习Rxjs 的基本使用，但是这个文档是Rxjs 5 的版本。其最基本的使用区别如下,Rxjs 6的操作符都放在pipe (管道)中配置，而Rxjs 5 的版本是直接调用

Rxjs 5

fromEvent(addBtn, 'click').throttleTime(3000).subscribe(() => {nameInput.value = +(nameInput.value) + 1})
复制代码

Rxjs 6

fromEvent(addBtn, 'click').pipe(throttleTime(3000)).subscribe(() => {nameInput.value = +(nameInput.value) + 1})
复制代码

fromEvent

使用方法

我们先从我们最常用的事件处理开始，Rxjs 对事件的处理有一个fromEvent 方法， 其最简单的一个范例如下：

import {fromEvent } from './esm2015';const addBtn = document.getElementById('add')
const minusBtn = document.getElementById('minus')
const nameInput = document.getElementById('name');
fromEvent(addBtn, 'click')  .subscribe(() => {nameInput.value = +(nameInput.value) + 1})fromEvent(minusBtn, 'click').subscribe(() => {nameInput.value = +(nameInput.value) - 1})
复制代码

其实现的效果如下图：

 

 

我们点击加号或者减号 button 去给Input赋值。

 

原理

从上面我们已经可以知道怎么去简单使用fromEvent, 下面我们根据源代码来一步步深入分析，其基本原理：

export function fromEvent(target, eventName, options, resultSelector) {if (isFunction(options)) {resultSelector = options;options = undefined;}if (resultSelector) {return fromEvent(target, eventName, options).pipe(map(args => isArray(args) ? resultSelector(...args) : resultSelector(args)));}return new Observable(subscriber => {function handler(e) {if (arguments.length > 1) {subscriber.next(Array.prototype.slice.call(arguments));}else {subscriber.next(e);}}setupSubscription(target, eventName, handler, subscriber, options);});
}
复制代码

fromEvent 其实就是一个方法， 可以传入四个参数，我们上面的Demo 只是传递了两个参数，我们先只分析只传递两个参数的情况： fromEvent 最终会返回一个Observable对象， 我们可以将上面的Demo 代码，进行简单的处理，如下：

import { fromEvent } from './esm2015';const addBtn = document.getElementById('add')
const minusBtn = document.getElementById('minus')
const nameInput = document.getElementById('name')
const addFromEventObj = fromEvent(addBtn, 'click')
addFromEventObj.subscribe(() => {nameInput.value = +(nameInput.value) + 1
})const minusFromEventObj = fromEvent(minusBtn, 'click')
minusFromEventObj.subscribe(() => {nameInput.value = +(nameInput.value) - 1
})
复制代码

我们将如下代码分成了两个步骤，

fromEvent(addBtn, 'click')  .subscribe(() => {nameInput.value = +(nameInput.value) + 1})复制代码

const addFromEventObj = fromEvent(addBtn, 'click')我们可以查看addFromEventObj对象，如下截图：

 

 

很简单，就是Observable 对象，其中有一个重要的属性_subscribe的属性， 执行的就是fromEvent 中return对象的传入的参数：

 

    return new Observable(subscriber => {function handler(e) {if (arguments.length > 1) {subscriber.next(Array.prototype.slice.call(arguments));}else {subscriber.next(e);}}setupSubscription(target, eventName, handler, subscriber, options);});
复制代码

其实fromEvent 方法，很简单，就是返回一个Observable 对象， 其他的基本就没有什么了。 其中点还是返回的这个对象，我们下面来深入分析Observable 对象.

Observable

Observable 的中文翻译就是可观察的, 表示一个可观察的对象，既然是一个可观察的对象，那观察到变化后，是不是要通知相应的观察者 呢？

构造函数

我们首先分析Observable 的构造函数：

    constructor(subscribe) {this._isScalar = false;if (subscribe) {this._subscribe = subscribe;}}
复制代码

其构造函数就接收一个参数subscribe ，其中文意思就是订阅 ，其实订阅 就是观察者 的概念，然后我们的可观察的对象 和观察者 对象就关联起来了。

const addFromEventObj = fromEvent(addBtn, 'click') 中addFromEventObj表示创建了一个可观察的 对象， 有了可观察的 对象，我们就需要对这个对象进行订阅 了， 我们下面就来分析subscribe方法

subscribe

subscribe的源码如下：

    subscribe(observerOrNext, error, complete) {const { operator } = this;const sink = toSubscriber(observerOrNext, error, complete);if (operator) {operator.call(sink, this.source);}else {sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?this._subscribe(sink) :this._trySubscribe(sink));}if (config.useDeprecatedSynchronousErrorHandling) {if (sink.syncErrorThrowable) {sink.syncErrorThrowable = false;if (sink.syncErrorThrown) {throw sink.syncErrorValue;}}}return sink;}
复制代码

我们目前先不考虑添加operator (操作符)的情况，我们下面来一一分析这个方法：

  1. const sink = toSubscriber(observerOrNext, error, complete); 创建了一个Subscriber 方法，
  2. 因为operator 为undefined, 所以条件判断语句会进入else,
            sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?this._subscribe(sink) :this._trySubscribe(sink));
复制代码

其中add()方法里面会先执行this._trySubscribe(sink), 然后执行： return this._subscribe(sink);, 我们应该还记得this._subscribe,是我们调用fromEvent方法， 返回Observable对象，传入构造函数的参数，代码如下：

subscriber => {function handler(e) {if (arguments.length > 1) {subscriber.next(Array.prototype.slice.call(arguments));}else {subscriber.next(e);}}setupSubscription(target, eventName, handler, subscriber, options);}
复制代码

这里就是给真实的Dom 元素进行事件的绑定，现在我们点击button ， 就会调用如上的handler方法， 主要实现是subscriber.next(e);, 其'subscriber' 也就是const sink = toSubscriber(observerOrNext, error, complete); 创建的sink对象，其对应就是esm2015\internal\Subscriber.js对象，现在我们查看其对应的next()方法， 其指向的是：

    _next(value) {this.destination.next(value);}
复制代码

其this.destination 属性， 是在Subscriber 构造函数赋值的, 是一个SafeSubscriber对象

 default:this.syncErrorThrowable = true;this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);break;
复制代码

其中destinationOrNext 对应的是subscribe 方法传入的参数，如下：

const addFromEventObj = fromEvent(addBtn, 'click')
addFromEventObj.subscribe(() => {nameInput.value = +(nameInput.value) + 1
})
复制代码

就是

() => {nameInput.value = +(nameInput.value) + 1
}
复制代码

下面我们继续来分析this.destination.next(value);, 其代码如下：

    next(value) {if (!this.isStopped && this._next) {const { _parentSubscriber } = this;if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {this.__tryOrUnsub(this._next, value);}else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {this.unsubscribe();}}}
复制代码

最终实现方法是this.__tryOrUnsub(this._next, value);, 这个方法传递了两个参数：

  1. this._next， 其在SafeSubscriber 构造函数中对其进行了赋值： next = observerOrNext;,也就是构造函数的第二个参数， 我们上面已经分析了创建SafeSubscriber 对象的地方this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);, 这个destinationOrNext就是subscribe方法传入的参数，如下：
const addFromEventObj = fromEvent(addBtn, 'click')
addFromEventObj.subscribe(() => {nameInput.value = +(nameInput.value) + 1
})
复制代码
  1. value, 也就是click 事件的对象MouseEvent

我们接下来具体分析**__tryOrUnsub** 方法，代码如下：

    __tryOrUnsub(fn, value) {try {fn.call(this._context, value);}catch (err) {this.unsubscribe();if (config.useDeprecatedSynchronousErrorHandling) {throw err;}else {hostReportError(err);}}}
复制代码

其主要实现就是fn.call(this._context, value);, 就会执行了subscribe 里面的方法了， 也就是执行：

() => {nameInput.value = +(nameInput.value) + 1
}
复制代码

pipe

上面我们已经基本理解了fromEvent 的基本使用方法，主要分析的是subscribe 方法，我们现在有个需求，我们要控制Button , 在3s 时间内， 我们只能点击一次， 以防止，恶意点击按钮.Rxjs 都是基于流来操作，Observable 对象提供了一个pipe(管道)的方法， 在进入到subscribe 订阅者方法之前，所以的数据需要进行加工，异常处理， 以保证subscribe收到的是正确的数据。我们下面来深入分析pipe 方法。 我们将我们的Demo 修改如下：

import { fromEvent } from './esm2015';
import { throttleTime } from './esm2015/operators'const addBtn = document.getElementById('add')
const minusBtn = document.getElementById('minus')
const nameInput = document.getElementById('name')
const addFromEventObj = fromEvent(addBtn, 'click')
const pipeObj = addFromEventObj.pipe(throttleTime(1000 * 3))
pipeObj.subscribe(() => {nameInput.value = +(nameInput.value) + 1})const minusFromEventObj = fromEvent(minusBtn, 'click')minusFromEventObj.pipe(throttleTime(1000 * 3)).subscribe(() => {nameInput.value = +(nameInput.value) - 1})
复制代码

上面我们通过.pipe(throttleTime(1000 * 3))添加了管道 ,其中传入了一个throttleTime (节流)操作符， 下面是pipe 方法的代码：

    pipe(...operations) {if (operations.length === 0) {return this;}var opts = pipeFromArray(operations);var result = opts(this);return result;}
复制代码

从上面方法，我们可以看出pipe 方法，可以传入多个操作符， 我们现在先只看下简单的，只传入一个操作符的情况， 如果只传入一个参数var opts = pipeFromArray(operations); 中opts对应的就是我们传入的throttleTime函数返回的方法，也就是如下：

export function throttleTime(duration, scheduler = async, config = defaultThrottleConfig) {return (source) => {return source.lift(new ThrottleTimeOperator(duration, scheduler, config.leading, config.trailing));}
}
复制代码

其中source 就是上面的this, 也就是Observable 对象，我们下面可以继续看下lift 方法：

    lift(operator) {const observable = new Observable();observable.source = this;observable.operator = operator;return observable;}
复制代码

返回了一个新的observable 对象，只是在添加了operator 属性。如下代码：

const addFromEventObj = fromEvent(addBtn, 'click')
const pipeObj = addFromEventObj.pipe(throttleTime(1000 * 3))
复制代码

pipeObj 如下图所示：

 

 

 

所以pipe 方法就是将一个(组)操作符挂载在一个新的observable 对象的operator 属性上。 我们还需要重新分析subscribe 方法

    subscribe(observerOrNext, error, complete) {const { operator } = this;const sink = toSubscriber(observerOrNext, error, complete);if (operator) {operator.call(sink, this.source);}else {sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?this._subscribe(sink) :this._trySubscribe(sink));}if (config.useDeprecatedSynchronousErrorHandling) {if (sink.syncErrorThrowable) {sink.syncErrorThrowable = false;if (sink.syncErrorThrown) {throw sink.syncErrorValue;}}}return sink;}
复制代码

我们在调用subscribe 方法之前，我们已经调用了pipe 方法,pipe 方法返回的对象， 已经有了operator 操作符，所以上面的逻辑分支会走if operator.call(sink, this.source);, call 代码如下：

    call(subscriber, source) {return source.subscribe(new ThrottleTimeSubscriber(subscriber, this.duration, this.scheduler, this.leading, this.trailing));}
复制代码

重新调用了subscribe 方法， 只是传入的第一个参数observerOrNext 是一个ThrottleTimeSubscriber对象， 我们重新回到subscribe 方法，const sink = toSubscriber(observerOrNext, error, complete);, 查看下：

export function toSubscriber(nextOrObserver, error, complete) {if (nextOrObserver) {if (nextOrObserver instanceof Subscriber) {return nextOrObserver;}if (nextOrObserver[rxSubscriberSymbol]) {return nextOrObserver[rxSubscriberSymbol]();}}if (!nextOrObserver && !error && !complete) {return new Subscriber(emptyObserver);}return new Subscriber(nextOrObserver, error, complete);
}
复制代码

从代码可以分析出，如果第一个参数nextOrObserver 是一个Subscriber类型， 就直接返回这个对象， 而我们的ThrottleTimeSubscriber 是继承与Subscriber对象的，所以sink 就是一个ThrottleTimeSubscriber对象。 我们又重新回到fromEvent 方法, 其中的subscriber指向的就是一个ThrottleTimeSubscriber对象。subscriber.next(e);调用的也是ThrottleTimeSubscriber对象的next 方法。

    return new Observable(subscriber => {function handler(e) {if (arguments.length > 1) {subscriber.next(Array.prototype.slice.call(arguments));}else {subscriber.next(e);}}setupSubscription(target, eventName, handler, subscriber, options);});
复制代码

后面我们来继续分析， 这个operator 操作符是怎么起作用的。

throttleTime

上面我们已经分析，pipe 方法就是将一个(组)操作符挂载在一个新的observable 对象的operator 属性上。现在我们来分析操作符具体是怎么工作的，我们可以先以throttleTime 操作符来进行分析。

上面我们已经分析了，我们在点击Button 的时候，会调用handler方法， 其中subscriber已经是一个ThrottleTimeSubscriber对象。

    return new Observable(subscriber => {function handler(e) {if (arguments.length > 1) {subscriber.next(Array.prototype.slice.call(arguments));}else {subscriber.next(e);}}setupSubscription(target, eventName, handler, subscriber, options);});
复制代码

我们下面来分析： ThrottleTimeSubscriber.next(e) 方法， 其代码如下：

    _next(value) {if (this.throttled) {if (this.trailing) {this._trailingValue = value;this._hasTrailingValue = true;}}else {this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this })this.add(this.throttled);if (this.leading) {this.destination.next(value);}}}
复制代码

这个方法很重要

  1. 首先加了一个throttled 标记变量， 用来标记是否已经启动了节流开关，一开始是为undefinded的 代码会进入else分支，
  2. 然后执行this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this })给throttled赋值，下一次进来的时候，throttled 就有值了。
  3. 执行this.destination.next(value);, 这个方法，会最终调用subscribe订阅方法中传递的方法，也就是
addFromEventObj = addFromEventObj.subscribe(() => {nameInput.value = +(nameInput.value) + 1
})
复制代码

总结：

这个方法是实现throttleTime 节流的关键点， 通过判断throttled 标记来判断是否要执行subscribe 中的方法。

下面我们来重点分析： this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this }).

首先： scheduler指向的是esm2015\internal\scheduler\AsyncAction.js对象， 我们查看下其schedule方法：

    schedule(state, delay = 0) {if (this.closed) {return this;}this.state = state;const id = this.id;const scheduler = this.scheduler;if (id != null) {this.id = this.recycleAsyncId(scheduler, id, delay);}this.pending = true;this.delay = delay;this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);return this;}
复制代码

其中最重要的是： this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);, 这里调用了一个requestAsyncId方法，其代码如下：

requestAsyncId(scheduler, id, delay = 0) {return setInterval(scheduler.flush.bind(scheduler, this), delay);}
复制代码

哈哈，这里设置了一个定时器setInterval, 这就是throttleTime生效的一个关键点。

总结：

setInterval 实现的功能是定时去清除 throttled 变量值，从而达到，我们在调用throttleTime(1000*3)这个操作符后，点击一次按钮后，3S内不能再次点击，但是3S后，又可以点击的原理

这个定时器的第一个参数是scheduler.flush.bind(scheduler, this), 其对应的是：esm2015/internal/scheduler/AsyncScheduler.js里的flush 方法，其代码如下：

    flush(action) {const { actions } = this;if (this.active) {actions.push(action);return;}let error;this.active = true;do {if (error = action.execute(action.state, action.delay)) {break;}} while (action = actions.shift());this.active = false;if (error) {while (action = actions.shift()) {action.unsubscribe();}throw error;}}
复制代码

会去遍历所有的actions, 然后去执行execute 方法， 传入的action 就是对应的AsyncAction 对象，execute 方法如下：

    execute(state, delay) {if (this.closed) {return new Error('executing a cancelled action');}this.pending = false;const error = this._execute(state, delay);if (error) {return error;}else if (this.pending === false && this.id != null) {this.id = this.recycleAsyncId(this.scheduler, this.id, null);}}
复制代码

然后会调用const error = this._execute(state, delay);, _execute 代码如下：

    _execute(state, delay) {let errored = false;let errorValue = undefined;try {this.work(state);}catch (e) {errored = true;errorValue = !!e && e || new Error(e);}if (errored) {this.unsubscribe();return errorValue;}}
复制代码

其中最重要的是调用了this.work(state)方法， work是this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this })传递的第一个参数

function dispatchNext(arg) {const { subscriber } = arg;subscriber.clearThrottle();
}
复制代码

最终会调用clearThrottle 方法，其代码如下：

    clearThrottle() {const throttled = this.throttled;if (throttled) {if (this.trailing && this._hasTrailingValue) {this.destination.next(this._trailingValue);this._trailingValue = null;this._hasTrailingValue = false;}throttled.unsubscribe();this.remove(throttled);this.throttled = null;}}
复制代码

其中很关键的一个步骤是将throttled 这个标记，设置为null this.throttled = null;, 为什么说很重要呢， 还记得我们上面有分析ThrottleTimeSubscriber, 这个class 下面的_next方法，其代码如下：

    _next(value) {if (this.throttled) {if (this.trailing) {this._trailingValue = value;this._hasTrailingValue = true;}}else {this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this })this.add(this.throttled);if (this.leading) {this.destination.next(value);}}}
复制代码

这个方法有判断throttled这个标记， 如果不为空，其实相当与什么也不做，只有为空的情况下，才会去执行this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this }), 也就是这个方法，会去执行我们subscribe 订阅里面的方法， 从而达到了，节流的效果。

let addFromEventObj = fromEvent(addBtn, 'click')
addFromEventObj = addFromEventObj.pipe(throttleTime(1000 * 10))
addFromEventObj = addFromEventObj.subscribe(() => {nameInput.value = +(nameInput.value) + 1
})
复制代码

总结

上面我们已经简单的分析了Rxjs 的基本使用方式，下面是我们这篇文章涉及的几个基本概念

(Observable)可观察的对象, (subscriber)观察者, (pipe)管道, (throttleTime)操作符 下面我们根据这几个概念来总结下Rxjs基于流来处理数据的整个过程(被观察对象-> 数据处理-> 观察者)

  1. 首先需要创建一个可观察对象， 在esm2015\internal\observable\文件夹下都是用来创建可观察对象的方法， 如上面我们Demo 用到的fromEvent就是其中一个，然后返回一个Observable对象， Observable 还有一个静态方法create可以直接创建一个个Observable对象
  2. pipe 就是将操作符挂载在Observable 对象的operator 属性上， 如果pipe 传递了多个操作符， 则在source属性(也是一个Observable)对象的operator， 层层递归，从右到左
addFromEventObj = addFromEventObj.pipe(throttleTime(1000 * 2),mapTo(1), scan((init, next) => init + next, 0))
复制代码

其对应的对象如下图：

 

 

 

  1. 然后调用subscribe方法， 里面的第一个参数就是观察者,如下的subscriber 方法。
let addFromEventObj = fromEvent(addBtn, 'click')
addFromEventObj = addFromEventObj.pipe(throttleTime(1000 * 2),mapTo(1), scan((init, next) => init + next, 0))
const subscriber = value => {nameInput.value = value
}
addFromEventObj = addFromEventObj.subscribe(subscriber)


作者：bluebrid
链接：https://juejin.im/post/5c00c9666fb9a049e307d398
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这篇关于rxjs 源码分析1-(fromEvent)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/509139。

相关文章

基于Go语言实现Base62编码的三种方式以及对比分析

基于Go语言实现Base62编码的三种方式以及对比分析

《基于Go语言实现Base62编码的三种方式以及对比分析》Base62编码是一种在字符编码中使用62个字符的编码方式,在计算机科学中,,Go语言是一种静态类型、编译型语言,它由Google开发并开源,... 目录一、标准库现状与解决方案1. 标准库对比表2. 解决方案完整实现代码（含边界处理）二、关键实现细
阅读更多...
PostgreSQL 序列(Sequence) 与 Oracle 序列对比差异分析

PostgreSQL 序列(Sequence) 与 Oracle 序列对比差异分析

《PostgreSQL序列(Sequence)与Oracle序列对比差异分析》PostgreSQL和Oracle都提供了序列(Sequence)功能,但在实现细节和使用方式上存在一些重要差异,... 目录PostgreSQL 序列(Sequence) 与 oracle 序列对比一 基本语法对比1.1 创建序
阅读更多...
Android实现一键录屏功能(附源码)

Android实现一键录屏功能(附源码)

《Android实现一键录屏功能(附源码)》在Android5.0及以上版本,系统提供了MediaProjectionAPI,允许应用在用户授权下录制屏幕内容并输出到视频文件,所以本文将基于此实现一个... 目录一、项目介绍二、相关技术与原理三、系统权限与用户授权四、项目架构与流程五、环境配置与依赖六、完整
阅读更多...
Android实现定时任务的几种方式汇总(附源码)

Android实现定时任务的几种方式汇总(附源码)

《Android实现定时任务的几种方式汇总(附源码)》在Android应用中,定时任务（ScheduledTask）的需求几乎无处不在：从定时刷新数据、定时备份、定时推送通知,到夜间静默下载、循环执行... 目录一、项目介绍1. 背景与意义二、相关基础知识与系统约束三、方案一：Handler.postDel
阅读更多...
慢sql提前分析预警和动态sql替换-Mybatis-SQL

慢sql提前分析预警和动态sql替换-Mybatis-SQL

《慢sql提前分析预警和动态sql替换-Mybatis-SQL》为防止慢SQL问题而开发的MyBatis组件,该组件能够在开发、测试阶段自动分析SQL语句,并在出现慢SQL问题时通过Ducc配置实现动... 目录背景解决思路开源方案调研设计方案详细设计使用方法1、引入依赖jar包2、配置组件XML3、核心配
阅读更多...
Java NoClassDefFoundError运行时错误分析解决

Java NoClassDefFoundError运行时错误分析解决

《JavaNoClassDefFoundError运行时错误分析解决》在Java开发中,NoClassDefFoundError是一种常见的运行时错误,它通常表明Java虚拟机在尝试加载一个类时未能... 目录前言一、问题分析二、报错原因三、解决思路检查类路径配置检查依赖库检查类文件调试类加载器问题四、常见
阅读更多...
Python中的Walrus运算符分析示例详解

Python中的Walrus运算符分析示例详解

《Python中的Walrus运算符分析示例详解》Python中的Walrus运算符（:=）是Python3.8引入的一个新特性,允许在表达式中同时赋值和返回值,它的核心作用是减少重复计算,提升代码简... 目录1. 在循环中避免重复计算2. 在条件判断中同时赋值变量3. 在列表推导式或字典推导式中简化逻辑
阅读更多...
Java程序进程起来了但是不打印日志的原因分析

Java程序进程起来了但是不打印日志的原因分析

《Java程序进程起来了但是不打印日志的原因分析》：本文主要介绍Java程序进程起来了但是不打印日志的原因分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Java程序进程起来了但是不打印日志的原因1、日志配置问题2、日志文件权限问题3、日志文件路径问题4、程序
阅读更多...
Java 正则表达式URL 匹配与源码全解析

Java 正则表达式URL 匹配与源码全解析

《Java正则表达式URL匹配与源码全解析》在Web应用开发中,我们经常需要对URL进行格式验证,今天我们结合Java的Pattern和Matcher类,深入理解正则表达式在实际应用中... 目录1.正则表达式分解：2. 添加域名匹配 (2)3. 添加路径和查询参数匹配 (3) 4. 最终优化版本5.设计思
阅读更多...
Java字符串操作技巧之语法、示例与应用场景分析

Java字符串操作技巧之语法、示例与应用场景分析

《Java字符串操作技巧之语法、示例与应用场景分析》在Java算法题和日常开发中,字符串处理是必备的核心技能,本文全面梳理Java中字符串的常用操作语法,结合代码示例、应用场景和避坑指南,可快速掌握字... 目录引言1. 基础操作1.1 创建字符串1.2 获取长度1.3 访问字符2. 字符串处理2.1 子字
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2