Little Child

Vue入门

2026-03-21T00:00:00+08:00

一、简介

Vue是一款用于构建用户界面的JavaScript框架，它基于标准HTML、CSS和JavaScript构建，并提供了一套声明式的、组件化的编程模型，可以高效地开发用户界面。无论是简单还是复杂的界面，Vue 都可以胜任。

二、语法

1、创建应用

可以通过createApp函数创建一个应用实例，并传入一个“根组件”来创建应用。

创建应用

import { createApp } from 'vue' // 从一个单文件组件中导入根组件 import App from './App.vue' const app = createApp(App) // 挂载到DOM元素上 app.mount('#app') 

应用配置

可以通过应用实例的.config对象进行应用级配置，例如配置错误处理器、注册全局组件或指令等。

app.config.errorHandler = (err) => { /* 处理错误 */ } // 全局注册 app.component('MyComponent', MyComponent) 

説明
- 挂载
  
  .mount()方法必须在应用配置之后调用，它返回的是根组件实例。
- 多应用实例
  
  可以在同一个页面上创建多个独立的Vue应用，每个应用都有自己的作用域。

2、模板语法

Vue的模板语法基于HTML，能够声明式地将组件实例的数据绑定到DOM上。

文本插值

双大括号{{ }}用于文本插值，数据会被解释为纯文本。

<span>Message: </span>

原始HTML

可以使用v-html指令输出真正的HTML。但需注意XSS风险，只对可信内容使用。

<span v-html="rawHtml"></span> 

指令

指令是带有v-前缀的特殊attribute，它的期望值是一个JavaScript表达式。

一个指令的任务是在其表达式的值变化时响应式地更新DOM。例如：
```
 <p v-if="seen">Now you see me</p> 
```
- 参数
某些指令会需要一个“参数”：在指令名后通过一个冒号隔开做标识。例如用v-bind指令来响应式地更新一个HTML attribute：
```
 <a v-bind:href="url"> ... </a>  <a :href="url"> ... </a> <a v-on:click="doSomething"> ... </a>  <a @click="doSomething"> ... </a> 
```
- 动态参数
在指令参数上也可以使用一个 JavaScript 表达式，需要包含在一对方括号内：
```
 <a v-bind:[attributeName]="url"> ... </a>  <a :[attributeName]="url"> ... </a> 
```
上面的attributeName会作为一个JavaScript表达式被动态执行，计算得到的值会被用作最终的参数。
属性绑定

可以使用v-bind指令响应式地绑定HTML属性，简写为:：
```
 <div :id="dynamicId"></div> 
```
- 同名简写
如果属性名与绑定的JavaScript变量名相同，可直接写，例如：:id：
```
 <div :id></div> 
```
- 布尔型属性
当值为真值或空字符串时，此属性(attribute)存在；如果为假值（例如null、 undefined、 false）时，属性会被移除。
```
 <button :disabled="isButtonDisabled">Button</button> 
```
使用JavaScript表达式

Vue支持在模板中绑定完整的JavaScript表达式，但每个绑定只能包含单一表达式（一段能够被求值的 JavaScript 代码）。

 {{ number + 1 }} {{ ok ? 'YES' : 'NO' }} <div :id="`list-${id}`"></div> 

下面的例子都是无效的：

 <!-- 这是一个语句，而非表达式 --> {{ var a = 1 }} <!-- 条件控制也不支持，请使用三元表达式 --> {{ if (ok) { return message } }} 

修饰符

以点.开头的特殊后缀，表示指令以特殊方式绑定。例如.prevent告诉v-on指令调用 event.preventDefault()。

<form @submit.prevent="onSubmit">...</form> 

3、响应式基础

声明响应式状态

选项式API

使用data选项，它返回一个对象，Vue会将其属性变为响应式。

 export default { data() { return { count: 0 } } } 

组合式API

在组合式API中，推荐使用ref()函数来声明响应式状态：

 import { ref } from 'vue' // 适用于基本类型，通过 .value 访问 const count = ref(0) console.log(count) // { value: 0 } console.log(count.value) // 0 count.value++ console.log(count.value) // 1 

如果要在组件模板中访问ref，需要在组件的setup()函数中声明并返回它们：

 import { ref } from 'vue' export default { // `setup` 是一个特殊的钩子，专门用于组合式 API。 setup() { const count = ref(0) // 将 ref 暴露给模板 return { count } } } 

 <div>8</div>

ref创建了一个包含value属性的对象。通过.value属性，Vue可以追踪其访问和修改，从而实现响应性。在模板中使用时，ref会自动“解包”，无需写.value。

另一种声明响应式状态的方式是使用reactive()API，与将内部值包装在特殊对象中的ref不同，reactive()将使对象本身具有响应性：

 // 适用于对象/数组，可直接访问属性 import { reactive } from 'vue' const state = reactive({ count: 0 }) 

在模板中使用：

 <button @click="state.count++"> </button> 

reactive()返回的是一个原始对象的代理Proxy，它和原始对象是不相等的；只有代理对象是响应式的，更改原始对象不会触发更新。因此，使用Vue的响应式系统的最佳实践是仅使用你声明对象的代理版本。

 const raw = {} const proxy = reactive(raw) // 代理对象和原始对象不是全等的 console.log(proxy === raw) // false 

reactive的局限是只能用于对象类型，不能替换整个对象，而且解构时会丢失响应性。因此，官方推荐使用ref()作为主要API。

 let state = reactive({ count: 0 }) // 上面的 ({ count: 0 }) 引用将不再被追踪，响应性连接已丢失！ state = reactive({ count: 1 }) // 当解构时，count 已经与 state.count 断开连接 let { count } = state // 不会影响原始的 state count++ // 该函数接收到的是一个普通的数字，并且无法追踪 state.count 的变化，必须传入整个对象以保持响应性 callSomeFunction(state.count) 

<script setup>

在setup()函数中手动暴露大量的状态和方法非常繁琐，因此可以使用<script setup>来大幅度地简化代码：

<script setup> import { ref } from 'vue' const count = ref(0) function increment() { count.value++ } </script>  <template> <button @click="increment"> 8 </button> </template> 

<script setup>中的顶层的导入、声明的变量和函数可以在同一组件的模板中直接使用。可以理解为模板是在同一作用域内声明的一个JavaScript函数。

DOM更新时机

Vue的DOM更新是异步的，修改响应式状态后，DOM不会立即更新；如果要等待更新完成，可以使用 nextTick()。

import { nextTick } from 'vue' async function increment() { count.value++ await nextTick() // 现在DOM已更新 } 

4、方法与计算属性

方法

在选项式API中，使用methods选项为组件添加方法，方法中的this会自动绑定到当前组件实例。

export default { methods: { increment() { this.count++ } } } 

计算属性

对于包含复杂逻辑的响应式数据，应使用计算属性。它基于其响应式依赖进行缓存，只有依赖变化时才会重新计算。

<script setup> import { reactive, computed } from 'vue' const author = reactive({ name: 'John Doe', books: [ 'Vue 2 - Advanced Guide', 'Vue 3 - Basic Guide', 'Vue 4 - The Mystery' ] }) // 一个计算属性 ref const publishedBooksMessage = computed(() => { return author.books.length > 0 ? 'Yes' : 'No' }) </script> <template> <p>Has published books:</p> <span></span> </template> 

上面的computed()方法接收一个getter函数，返回值为一个计算属性ref，赋值给publishedBooksMessage（计算属性）；和其他一般的ref类似，可以通过publishedBooksMessage.value访问计算结果。计算属性ref也会在模板中自动解包，因此在模板表达式中引用时无需添加.value。

可写计算属性

计算属性默认是只读的，如果需要用到“可写”的属性，则可以通过同时提供getter和setter方法来创建：

<script setup> import { ref, computed } from 'vue' const firstName = ref('John') const lastName = ref('Doe') const fullName = computed({ // getter get() { return firstName.value + ' ' + lastName.value }, // setter set(newValue) { // 注意：这里使用的是解构赋值语法 [firstName.value, lastName.value] = newValue.split(' ') } }) </script> 

方法与计算属性的区别

计算属性有缓存，方法则没有。若依赖不改变，多次访问计算属性会直接返回缓存结果，性能更优。

5、类与样式绑定

数据绑定的一个常见需求场景是操纵元素的CSS class列表和内联样式，可以和其他attribute一样使用 v-bind将它们和动态的字符串绑定。但在处理比较复杂的绑定时，通过拼接生成字符串比较麻烦且容易出错。因此，Vue专门为class和style的v-bind用法提供了特殊的功能增强：除了字符串外，表达式的值也可以是对象或数组。

绑定HTML Class
- 对象
根据数据动态切换class。
```
 <div :class="{ active: isActive, 'text-danger': hasError }"></div> 
```
- 数组
绑定多个class。
```
 <div :class="[activeClass, errorClass]"></div> 
```
- 在组件上使用
class会被自动添加到组件的根元素上，并与其已有class合并。例如：

组件MyComponent：
```
 <p class="foo bar">Hi!</p> 
```
在使用时添加一些 class：
```
  <MyComponent class="baz boo" /> 
```
渲染出的HTML为：
```
 <p class="foo bar baz boo">Hi!</p> 
```
绑定内联样式
- 对象
推荐使用camelCase：
```
 const activeColor = ref('red') const fontSize = ref(30) 
```
```
 <div :style="{ color: activeColor, fontSize: fontSize + 'px' }"></div> 
```
也支持kebab-cased形式的CSS属性key (对应其 CSS 中的实际名称)，例如：
```
 const styleObject = reactive({ color: 'red', fontSize: '30px' }) 
```
```
 <div :style="{ 'font-size': fontSize + 'px' }"></div>  <div :style="styleObject"></div> 
```
- 数组
绑定一个包含多个样式对象的数组，这些对象会被合并后渲染到同一元素上：
```
 <div :style="[baseStyles, overridingStyles]"></div> 
```
- 自动前缀
Vue会为需要浏览器特殊前缀的CSS属性自动添加前缀。Vue是在运行时检查该属性是否支持在当前浏览器中使用。如果浏览器不支持某个属性，那么将尝试加上各个浏览器特殊前缀，以找到哪一个是被支持的。

6、条件渲染

v-if/v-else-if/v-else

“真实的”按条件渲染，确保了在切换时，条件区块内的事件监听器和子组件都会被销毁与重建。同时也是惰性的：如果在初次渲染时条件值为false，则不会做任何事；只有当条件首次变为true时才被渲染。适合切换频率低的场景。

<div v-if="type === 'A'"> A </div> <div v-else-if="type === 'B'"> B </div> <div v-else-if="type === 'C'"> C </div> <div v-else> Not A/B/C </div> 

<template>上的v-if：可用于包裹多个元素，但最终渲染结果不会包含<template>本身。

<template v-if="ok"> <h1>Title</h1> <p>Paragraph 1</p> <p>Paragraph 2</p> </template> 

v-else和v-else-if也可以在

v-show

元素始终被渲染，仅切换其display CSS属性，适合频繁切换的场景。

<h1 v-show="ok">Hello!</h1> 

v-show不支持在<template>元素上使用。

7、列表渲染

v-for

基于数组或对象渲染列表，语法为item in items，第二个参数为索引或键名（可选）。

数组

 const items = ref([{ message: 'Foo' }, { message: 'Bar' }]) 

 <li v-for="item in items"> </li> <li v-for="(item, index) in items"> - </li> 

对象

 const myObject = reactive({ title: 'How to do lists in Vue', author: 'Jane Doe', publishedAt: '2016-04-10' }) 

 <ul> <li v-for="value in myObject"> </li> </ul> <!--第二个参数表示属性名--> <li v-for="(value, key) in myObject"> : </li> <!--第三个参数表示位置索引--> <li v-for="(value, key, index) in myObject"> . : </li> 

为每个列表项提供一个唯一的key，可以帮助Vue高效地跟踪节点状态，实现重用和重新排序。推荐在任何可能的时候都使用key。

<div v-for="item in items" :key="item.id"> <!-- 内容 --> </div> 

使用<template v-for>时，key应该被放置在<template>这个容器上：

<template v-for="todo in todos" :key="todo.name"> <li></li> </template> 

数组变化侦测
- 变更方法（改变原数组）
Vue 能够侦听响应式数组的变更方法，并在它们被调用时触发相关的更新。这些变更方法包括：push()、pop()、shift()、unshift()、splice()、sort()、reverse()。
- 替换方法（返回新数组）
filter()、concat()、slice()不会更改原数组，而总是返回一个新数组。
```
 // `items` 是一个数组的 ref items.value = items.value.filter((item) => item.message.match(/Foo/)) 
```
展示过滤或排序后的结果

建议使用计算属性来处理显示过滤或排序后的列表，以避免直接修改原始数据。

const numbers = ref([1, 2, 3, 4, 5]) const evenNumbers = computed(() => { return numbers.value.filter((n) => n % 2 === 0) }) 

<li v-for="n in evenNumbers"></li> 

8、事件处理

可以使用v-on指令(简写为@)来监听DOM事件，并在事件触发时执行对应的JavaScript语句。用法：v-on:click="handler"或@click="handler"。

事件处理器

事件处理器(handler)的值可以是：内联事件处理器(直接执行JavaScript语句)或方法事件处理器(指向组件中定义的方法名)。
- 内联事件处理器
事件被触发时执行的内联JavaScript语句(与onclick类似)，内联事件处理器通常用于简单场景，例如：
```
 const count = ref(0) 
```
```
 <button @click="count++">Add 1</button> <p>Count is: 8</p> 
```
- 方法事件处理器
当事件处理器的逻辑比较复杂时，内联代码方式变得不够灵活，此时可以使用v-on指定一个方法名或对某个方法的调用：
```
 const name = ref('Vue.js') function greet(event) { alert(`Hello ${name.value}!`) // `event` 是 DOM 原生事件 if (event) { alert(event.target.tagName) } } 
```
```
  <button @click="greet">Greet</button> 
```

事件修饰符

事件修饰符简化了DOM事件细节的处理，例如：stop（停止冒泡）、.prevent（阻止默认行为）、.once（只触发一次）等，可以链式调用。

 <!-- 单击事件将停止传递 --> <a @click.stop="doThis"></a> <!-- 提交事件将不再重新加载页面 --> <form @submit.prevent="onSubmit"></form> <!-- 修饰语可以使用链式书写 --> <a @click.stop.prevent="doThat"></a> <!-- 也可以只有修饰符 --> <form @submit.prevent></form> <!-- 仅当 event.target 是元素本身时才会触发事件处理器 --> <!-- 例如：事件处理器不来自子元素 --> <div @click.self="doThat">...</div> 

按键修饰符

在监听键盘事件时，经常需要检查特定的按键。Vue允许在v-on或@监听按键事件时添加按键修饰符。例如：

<!-- 仅在 `key` 为 `Enter` 时调用 `submit` --> <input @keyup.enter="submit" /> 

可以直接使用KeyboardEvent.key暴露的按键名称作为修饰符，但需要转为kebab-case形式。例如：

<input @keyup.page-down="onPageDown" /> 

按键别名

Vue为一些常用的按键提供了别名：.enter、.tab、.delete、.esc、.space、.up、.down、.left、.right。

系统按键修饰符

也可以使用.ctrl、.alt、.shift、.meta等系统按键修饰符来触发鼠标或键盘事件监听器，只有当按键被按下时才会触发。

.exact

使用.exact修饰符可台精确控制触发事件所需的系统修饰符的组合。

<!-- 当按下 Ctrl 时，即使同时按下 Alt 或 Shift 也会触发 --> <button @click.ctrl="onClick">A</button> <!-- 仅当按下 Ctrl 且未按任何其他键时才会触发 --> <button @click.ctrl.exact="onCtrlClick">A</button> <!-- 仅当没有按下任何系统按键时触发 --> <button @click.exact="onClick">A</button> 

鼠标按键修饰符

.left、.right、.middle这些修饰符将处理程序限定为由特定鼠标按键触发的事件。

9、表单输入绑定

v-model

使用v-model指令可以简化将表单输入框的内容同步到JavaScript中相应的变量过程，即在表单<input>、<textarea>、<select>元素上创建双向数据绑定，它会根据控件类型自动使用正确的属性和事件。例如：

 <input :value="text" @input="event => text = event.target.value"> 

使用v-model可以简化为：

 <input v-model="text"> 

文本/多行文本

绑定value并监听input事件。

 <p>Message is: </p> <input v-model="message" placeholder="edit me" /> 

在<textarea>中不支持插值表达式，需要使用v-model来替代：

 <!-- 错误 --> <textarea></textarea> <!-- 正确 --> <textarea v-model="text"></textarea> 

复选框/单选按钮

绑定checked并监听change事件。

 <input type="checkbox" id="checkbox" v-model="checked" /> <label for="checkbox"></label> <div>Picked: </div> <input type="radio" id="one" value="One" v-model="picked" /> <label for="one">One</label> <input type="radio" id="two" value="Two" v-model="picked" /> <label for="two">Two</label> 

选择器

绑定value并监听change事件。

 <div>Selected: </div> <select v-model="selected"> <option disabled value="">Please select one</option> <option>A</option> <option>B</option> <option>C</option> </select> 

值绑定

对于单选按钮、复选框和选择器选项，v-model绑定的值通常是静态的字符串或布尔值，可以通过v-bind将复选框、单选按钮等的值绑定到动态数据，支持非字符串值。

复选框

true-value和false-value是Vue特有的属性，仅支持和v-model配套使用。

 <!--这里 toggle 属性的值会在选中时被设为 'yes'，取消选择时设为 'no'。--> <input type="checkbox" v-model="toggle" true-value="yes" false-value="no" /> 

可以通过v-bind将其绑定为其他动态值：

 <input type="checkbox" v-model="toggle" :true-value="dynamicTrueValue" :false-value="dynamicFalseValue" /> 

单选按钮

 <!--pick 会在第一个按钮选中时被设为 first，在第二个按钮选中时被设为 second。--> <input type="radio" v-model="pick" :value="first" /> <input type="radio" v-model="pick" :value="second" /> 

选择器选项

 <select v-model="selected"> <!-- 内联对象字面量，当选项被选中，selected 会被设为该对象字面量值 { number: 123 } --> <option :value="{ number: 123 }">123</option> </select> 

修饰符
- .lazy
默认情况下，v-model会在每次input事件后更新数据，使用.lazy将其改为在每次change事件后更新数据：
```
  <input v-model.lazy="msg" /> 
```
- .number
自动将用户输入转为数字：
```
 <input v-model.number="age" /> 
```
如果该值无法被parseFloat()处理，那么将返回原始值。特别是当输入为空时 (例如用户清空输入字段之后)，会返回一个空字符串。
- .trim
自动去除输入内容两端的空格：
```
 <input v-model.trim="msg" /> 
```

10、侦听器

在Vue中，侦听器用于在响应式数据变化时执行特定逻辑，例如：异步请求、操作DOM、或根据一个值的变化去修改另一个值等。

watch

在组合式API中，可以使用watch函数在每次响应式状态发生变化时触发回调函数，watch的第一个参数为数据源，可以是：ref、reactive对象、getter函数或由以上类型组成的数组。

<script setup> import { ref, watch } from 'vue' const question = ref('') const answer = ref('') watch(question, async (newQuestion, oldQuestion) => { if (newQuestion.includes('?')) { // 执行异步操作 const res = await fetch('https://yesno.wtf/api') answer.value = (await res.json()).answer } }) </script> 

在选项式API中可以通过watch选项实现：

export default { data() { return { question: '', answer: '' } }, watch: { // 监听 question 的变化，参数为新值和旧值 question(newQuestion, oldQuestion) { if (newQuestion.includes('?')) { this.getAnswer() } } }, methods: { async getAnswer() { /* ... */ } } } 

深层侦听器

默认情况下，watch是浅层的：即只有数据源本身的引用发生变化才会触发，嵌套属性的变化不会触发。

可以使用reactive()或deep选项实现：

reactive

 // 组合式：直接传入 reactive 对象 const state = reactive({ user: { name: '张三' } }) watch(state, () => { console.log('state 中任何属性变化都会触发') }) state.user.name = '李四' // 触发侦听器 // 如果需要侦听某个嵌套属性，必须使用 getter watch(() => state.user.name, (newName) => { console.log('name 变化了', newName) }) 

deep

组合式：

 watch(() => state.someObject, (newVal, oldVal) => { // 仅当 someObject 被替换时触发 }, { deep: true }) // 加上 deep 后，内部属性变化也会触发 

选项式：

 export default { watch: { someObject: { handler(newVal, oldVal) { /* ... */ }, deep: true } } } 

深层侦听会递归遍历对象的所有属性，当数据庞大时开销较大，请谨慎使用。

即时回调

如果希望侦听器在创建时立即执行一次，而不必等待数据第一次变化时，可以使用immediate。例如：进入页面就拉取数据，之后每次参数变化再重新拉取。

组合式：

watch(source, (newVal) => { // 立即执行一次，之后每次 source 变化再执行 }, { immediate: true }) 

选项式：

export default { watch: { question: { handler(newQuestion) { /* ... */ }, immediate: true } } } 

一次性侦听器

如果只希望侦听器在数据变化时仅触发一次（不包括立即执行的那次），可以使用once。

watch(source, () => { // 仅第一次变化时执行 }, { once: true }) 

watchEffect

watchEffect会自动追踪其回调函数中使用到的所有响应式数据，当其中任何一个变化时，回调会重新执行。它相当于一个更简洁的watch + immediate: true，但无法获取旧值。

import { watchEffect } from 'vue' const count = ref(0) const name = ref('张三') watchEffect(() => { // 会自动追踪 count.value 和 name.value console.log(`count: ${count.value}, name: ${name.value}`) }) // 立即输出：count: 0, name: 张三 count.value++ // 输出：count: 1, name: 张三 name.value = '李四' // 输出：count: 1, name: 李四 

副作用清理

Vue提供了onWatcherCleanup或回调参数onCleanup来实现副作用的清理。例如：当侦听器中执行异步操作（如fetch），在上一次请求完成前，数据又发生了变化，此时应当取消过时的请求，避免状态冲突。

onWatcherCleanup

 <script setup> import { watch, onWatcherCleanup } from 'vue' const id = ref(1) watch(id, (newId) => { const controller = new AbortController() fetch(`/api/${newId}`, { signal: controller.signal }) .then(res => res.json()) .then(data => { /* 处理数据 */ }) // 注册清理函数，当 id 再次变化时，会先调用此函数 onWatcherCleanup(() => { controller.abort() // 取消过时的请求 }) }) </script> 

onCleanup

 watch(id, (newId, oldId, onCleanup) => { const controller = new AbortController() fetch(`/api/${newId}`, { signal: controller.signal }) onCleanup(() => controller.abort()) }) 

回调触发时机

Vue默认会在父组件更新之后、当前组件的DOM更新之前调用侦听器回调。如果你需要访问更新后的DOM，可以指定flush: 'post'。

// 组合式 watch(source, callback, { flush: 'post' }) watchEffect(callback, { flush: 'post' }) // 快捷写法 import { watchPostEffect } from 'vue' watchPostEffect(() => { // 在 DOM 更新后执行 }) 

如果需要在Vue进行任何更新之前触发，可以使用flush: 'sync'：

watch(source, callback, { flush: 'sync' }) watchEffect(callback, { flush: 'sync' }) // 快捷写法 import { watchSyncEffect } from 'vue' watchSyncEffect(() => { /* 在响应式数据变化时同步执行 */ }) 

停止侦听器

在setup()或<script setup>中用同步语句创建的侦听器，会自动绑定到宿主组件实例上，并且会在宿主组件卸载时自动停止。如果用异步回调创建一个侦听器，那么它不会绑定到当前组件上，必须手动停止以防内存泄漏。

<script setup> import { watchEffect } from 'vue' // 它会自动停止 watchEffect(() => {}) // ...这个则不会！ setTimeout(() => { watchEffect(() => {}) }, 100) </script> 

要手动停止一个侦听器，需要调用watch或watchEffect返回的函数：

const unwatch = watchEffect(() => {}) // ...当该侦听器不再需要时 unwatch() 

一般情况很少需要异步创建侦听器，尽可能选择同步创建。如果需要等待一些异步数据，可以使用以下方式：

// 需要异步请求得到的数据 const data = ref(null) watchEffect(() => { if (data.value) { // 数据加载后执行某些操作... } }) 

11、模板引用

Vue的声明性渲染模型抽象了大部分对DOM的直接操作，但在某些情况下，如果仍然需要直接访问底层DOM元素，可以使用ref属性。

<input ref="input"> 

ref允许在一个特定的DOM元素或子组件实例被挂载后，获得对它的直接引用。使用场景：例如在组件挂载时将焦点设置到一个input元素上，或者在一个元素上初始化一个第三方库。

<script setup> // 在组合式 API 中获取引用，可以使用辅助函数 useTemplateRef() import { useTemplateRef, onMounted } from 'vue' // 第一个参数必须与模板中的 ref 值匹配 const input = useTemplateRef('my-input') onMounted(() => { // 只可在组件挂载后才能访问模板引用 input.value.focus() }) </script> <template> <input ref="my-input" /> </template> 

模板引用也可以被用在一个子组件上。这种情况下引用中获得的值是组件实例：

<script setup> import { useTemplateRef, onMounted } from 'vue' import Child from './Child.vue' const childRef = useTemplateRef('child') onMounted(() => { // childRef.value 将持有 <Child /> 的实例 }) </script> <template> <Child ref="child" /> </template> 

12、组件

定义组件

通常使用单文件组件（.vue文件），它在一个文件中封装了模板、脚本和样式。

<script setup> import { ref } from 'vue' const count = ref(0) </script> <template> <button @click="count++">You clicked me 8 times.</button> </template> 

如果不使用构建步骤时，一个Vue组件以一个包含Vue特定选项的JavaScript对象来定义：

import { ref } from 'vue' export default { setup() { const count = ref(0) return { count } }, template: ` <button @click="count++"> You clicked me 8 times. </button>` } 

组件注册

一个Vue组件在使用前需要先被“注册”，有两种方式：全局注册和局部注册。
- 全局注册
通过使用Vue应用实例的.component()方法，可以让组件在当前Vue应用中全局可用。
```
 import { createApp } from 'vue' const app = createApp({}) app.component( // 注册的名字 'MyComponent', // 组件的实现 { /* ... */ } ) 
```
如果使用单文件组件，可以注册被导入的.vue文件：
```
 import MyComponent from './App.vue' app.component('MyComponent', MyComponent) 
```
.component()方法支持链式调用。
```
 app .component('ComponentA', ComponentA) .component('ComponentB', ComponentB) .component('ComponentC', ComponentC) 
```
- 局部注册
局部注册的组件需要在使用它的父组件中显式导入，并且只能在该父组件中使用。它的优点是使组件之间的依赖关系更加明确，并且对tree-shaking更加友好。

在使用<script setup>的单文件组件中，导入的组件可以直接在模板中使用，无需注册：
```
 <script setup> import ComponentA from './ComponentA.vue' </script> <template> <ComponentA /> </template> 
```
如果没有使用<script setup>，则需要使用components选项来显式注册：
```
 import ComponentA from './ComponentA.js' export default { components: { ComponentA }, setup() { // ... } } 
```
使用组件

在父组件中导入并注册（全局或局部）后，即可作为自定义标签使用。例如：把计数器组件放在了一个叫做ButtonCounter.vue的文件中，这个组件将会以默认导出的形式被暴露给外部。

<!--通过 <script setup>，导入的组件都在模板中直接可用。--> <script setup> import ButtonCounter from './ButtonCounter.vue' </script> <template> <h1>Here is a child component!</h1> <ButtonCounter /> </template> 

传递props

父组件通过props属性向子组件传递数据，子组件通过defineProps（组合式）或props选项（选项式）声明接收。props是一种特别的属性，可以在组件上声明注册：

<script setup> defineProps(['title']) </script> <template> <h4></h4> </template> 

如果没有使用<script setup>，props必须以props选项的方式声明，props对象会作为setup()函数的第一个参数被传入：

export default { props: ['title'], setup(props) { console.log(props.title) } } 

defineProps是一个仅<script setup>中可用的编译宏命令，并不需要显式地导入，声明的props会自动暴露给模板。defineProps会返回一个对象，其中包含了可以传递给组件的所有props：

const props = defineProps(['title']) console.log(props.title) 

例如，在父组件中会有如下的一个博客文章数组：

const posts = ref([ { id: 1, title: 'My journey with Vue' }, { id: 2, title: 'Blogging with Vue' }, { id: 3, title: 'Why Vue is so fun' } ]) 

之后可以使用v-for来渲染：

<BlogPost v-for="post in posts" :key="post.id" :title="post.title" /> 

监听事件

在Vue中，通过自定义事件实现子组件向父组件传递消息或数据，父组件通过v-on或@监听子组件触发的事件，子组件则通过$emit（选项式 API）或defineEmits（组合式 API）来触发事件。

$emit

$emit('事件名', 参数1, 参数2, ...)

子组件Child.vue：

<template> <button @click="sendMessage">点击向父组件发送消息</button> </template> <script> export default { methods: { sendMessage() { // 触发名为 'greet' 的自定义事件，并携带一个字符串参数 this.$emit('greet', 'Hello from child component!') } } } </script> 

父组件：

使用@greet="handleGreet"监听子组件触发的greet事件。

<template> <div> <Child @greet="handleGreet" /> <p>收到子组件的消息：</p> </div> </template> <script> import Child from './Child.vue' export default { components: { Child }, data() { return { messageFromChild: '' } }, methods: { handleGreet(msg) { this.messageFromChild = msg } } } </script> 

defineEmits

defineEmits()方法声明可触发的事件，它返回的emit函数用于触发事件。

子组件Child.vue：

<template> <button @click="sendMessage">点击向父组件发送消息</button> </template> <script setup> // 声明该组件可以触发的自定义事件 const emit = defineEmits(['greet']) const sendMessage = () => { // 触发 'greet' 事件，携带参数 emit('greet', 'Hello from child component!') } </script> 

父组件：

<template> <div> <Child @greet="handleGreet" /> <p>收到子组件的消息：</p> </div> </template> <script setup> import { ref } from 'vue' import Child from './Child.vue' const messageFromChild = ref('') const handleGreet = (msg) => { messageFromChild.value = msg } </script> 

使用defineEmits不仅能让代码更清晰，还能在TypeScript中提供类型检查。

插槽

如果想实现和HTML元素一样向组件中传递内容，可以通过<slot>元素实现。

AlertBox.vue：

<template> <div class="alert-box"> <strong>This is an Error for Demo Purposes</strong> <slot /> </div> </template> <style scoped> .alert-box { /* ... */ } </style> 

父组件：

<AlertBox> Something bad happened. </AlertBox>

最终渲染出来的内容如下：

This is an Error for Demo Purposes Something bad happened.

动态组件

如果需要在两个组件间来回切换，例如Tab界面，可以通过<component>元素和特殊的is属性来实现：

<!-- currentTab 改变时组件也改变 --> <component :is="tabs[currentTab]"></component> 

被传给:is的值可以是被注册的组件名或导入的组件对象。当使用<component :is="...">来在多个组件间作切换时，被切换掉的组件会被卸载。

13、生命周期

每个Vue组件实例在创建时都需要经历一系列的初始化步骤，比如设置好数据侦听、编译模板、挂载实例到DOM，以及在数据改变时更新DOM等。在此过程中，可以通过生命周期钩子函数在特定阶段运行指定的代码。

注册生命周期钩子函数

例如，使用onMounted可以在组件完成初始渲染并创建DOM节点后运行代码：
```
 <script setup> import { onMounted } from 'vue' onMounted(() => { console.log(`the component is now mounted.`) }) </script> 
```
还有其他一些钩子，会在实例生命周期的不同阶段被调用，常用的如下：
- beforeCreate
实例初始化之后被调用。
- created
实例创建完成后被立即调用。此时，组件实例已处理完响应式状态，但尚未挂载。可以在此进行数据请求、设置事件监听等。
- beforeMount
在挂载开始之前被调用。
- mounted
实例被挂载后调用，此时DOM已生成。常用于操作DOM、初始化第三方库。
- beforeUpdate
响应式数据变化后，DOM重新渲染前调用。可用于在更新前访问现有DOM。
- updated
由于数据变化导致的DOM重新渲染完成后调用。执行时请避免修改状态，以免触发无限更新循环。
- beforeUnmount
实例卸载之前调用。此阶段实例仍然完全可用。
- unmounted
实例卸载后调用。可以在此实现清理逻辑、移除事件监听器等。

参考资料

Vue.js简介

ERP基础

2026-02-22T00:00:00+08:00

一、简介

1、简介

ERP（企业资源计划）是一种集成了销售、采购、制造、财务、质量等管理功能，以计划与控制为主线，以信息技术为平台，面向供应链管理的现代企业管理思想、方法和工具。

2、基础概念

物料编码

每种物料唯一的“身份证”，必须唯一、实用、标准化。
物料清单（BOM）

产品的“配方”，描述成品由哪些零部件组成、用量多少。
工作中心

生产加工的基本单元（一台设备、一个班组、一个车间）。
工艺路线

产品的“制作步骤”，包括工序顺序、所用设备、加工时间。
工作日历

工厂的“日历”，标明工作日、休息日、检修日。
独立需求与相关需求

独立需求来自外部订单，相关需求由物料清单（BOM）计算得出。

3、核心效益

成功实施ERP可带来以下效益： * 库存下降：30%–50% * 延期交货减少：80% * 采购提前期缩短：50% * 制造成本降低：12% * 存货周转率提高50%以上 

二、发展历程

ERP不是凭空出现的，它是为了解决实际问题一步步发展而来的；它的每一次演进都是为解决前一个阶段留下的问题，同时扩展管理的范围。

ERP的发展史，就是企业管理者不断突破管理边界、整合更多资源、追求更高效率的历史：从库存到物料，从物料到能力，从能力到财务，从财务到供应链；每一步都在回答一个问题：如何让企业资源发挥最大价值？

1930s 1960s 1970s 1980s 1990s 2000s→ │ │ │ │ │ │ ▼ ▼ ▼ ▼ ▼ ▼ 订货点法 → 基本MRP → 闭环MRP → MRPⅡ → ERP → ERPⅡ/云ERP (库存控制) (物料需求) (能力闭环) (财务集成) (供应链) (扩展与智能) 

1、订货点法

20世纪初，随着工业化大生产的发展，企业面临一个核心问题：如何保证生产不中断，又不积压太多库存？

可以为每种物料设置一个最大库存量和安全库存量。当库存消耗到安全库存线时，就发出订货指令，补充到最大库存。

问题与局限

假设需求均匀，不适用于制造过程：它把所有需求都当作独立需求，无法区分成品的市场需求和零部件的派生需求。

2、基本MRP

概念

MRP：Material Requirement Planning，物资需求计划。
核心思想

物料的需求量可以根据产品的结构（BOM）计算出来，而不是靠猜测。

例如：如果一家汽车公司计划每天生产400辆轿车，那么它就需要2000个轮子。（相关需求）
问题与局限
- 没有考虑生产能力：算出来需要生产100个零件，但设备可能根本做不出来
- 没有反馈机制：计划执行情况无法影响后续计划

3、闭环MRP

闭环MRP在基本MRP的基础上增加了两个关键环节：能力需求计划（CRP）和执行与反馈。它形成了“计划—执行—反馈—调整”的完整闭环，成为一个完整的生产计划与控制系统。

4、MRPⅡ

MRPⅡ的缩写虽然还是MRP（物料需求计划），但内涵完全不同，MRPII：Manufacturing Resource Planning（制造资源计划）。

MRP解决的是“缺什么”的问题，而MRPⅡ解决的是“如何用好所有资源”的问题。

MRPⅡ将生产、财务、销售、采购、工程技术等子系统集成一体，体现了“计划—执行—控制”的完整逻辑。它将企业的所有制造资源纳入管理，并实现物流与资金流同步，是现代ERP的直接前身。

5、ERP

1990年4月12日，美国加特纳集团（Gartner Group）在研究报告《ERP：设想下一代的MRPⅡ》中首次提出“ERP”概念。

ERP与MRPⅡ的主要区别如下：

对比维度	MRPⅡ	ERP
资源范围	企业内部资源	整个供应链（客户、供应商、分销网络）
生产方式	支持单一生产类型	支持混合型制造（按库存生产MTO、按订单生产MTS、按订单装配ATO、按订单设计ETO）
管理功能	制造、分销、财务	增加质量管理、运输管理、设备管理、工作流管理
事务控制	事中控制为主	强调事前控制（在线分析、实时决策）

ERP在MRPⅡ的基础上，打破企业四壁，将管理范围从企业内部扩展到整个供应链，成为企业级的管理平台。

ERP的典型功能模块包括：采购管理、销售管理、库存管理、生产管理、财务管理、成本管理、质量管理、人力资源管理。

ERP的核心管理思想：

供应链管理思想
- 企业竞争是供应链与供应链的竞争
- 将供应商、制造工厂、分销网络、客户纳入统一管理
精益生产与敏捷制造
- 精益生产
  
  与供应商、客户建立长期合作伙伴关系
- 敏捷制造
  
  面对新机会，快速组建“虚拟工厂”，最短时间推出新产品
事先计划与事中控制
- 事先计划
  
  完整的计划体系（MPS、MRP、CRP、采购计划、利润计划、财务预算）
- 事中控制
  
  业务发生同时自动生成会计凭证，实现事中控制

6、ERPⅡ

加特纳集团在2000年前后提出ERPⅡ的概念，核心方向向外部延伸：加强CRM（客户关系管理）、SCM（供应链管理）、PLM（产品生命周期管理），并且从以产品为中心转向以客户为中心、从企业内部集成转向跨企业协同。

现代ERP的发展趋势：

云ERP

软件即服务（SaaS），降低实施成本，便于中小企业采用。
智能ERP

集成人工智能、机器学习，实现预测性分析、智能推荐。
移动ERP

支持手机端访问，管理者随时随地掌握运营数据。
行业化

针对不同行业（制造、零售、医疗、建筑）提供专业化解决方案。
平台化

ERP成为企业数字化平台的核心，与IoT、大数据、AI融合。

三、计划体系

ERP的计划体系是一个多层次的、逐级细化的金字塔结构：

 ┌─────────────────────┐ │ 经营规划 ← 战略层 │ (Business Plan) │ └──────────┬──────────┘ ▼ ┌─────────────────────┐ │ 销售与运作规划 ← 战术层 │ (S&OP) │ └──────────┬──────────┘ ▼ ┌─────────────────────┐ │ 主生产计划 ← 操作层 │ (MPS) │ (粗粒度) └──────────┬──────────┘ ▼ ┌────────────────────┼────────────────────┐ ▼ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ 物料需求计划 能力需求计划 分销需求计划 │ (MRP) │ │ (CRP) │ │ (DRP) │ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ ▼ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ 采购作业控制 生产作业控制 分销作业控制 │ (PO) │ │ (PAC) │ │ (DRP执行) └─────────────────┘ └─────────────────┘ └─────────────────┘ 

它有以下关键特征：

层层递进

从战略到战术到执行，从宏观到微观。
逐级细化

上一层计划是下一层计划的输入。
闭环控制

执行反馈影响后续计划。
双重约束

同时考虑物料约束（MRP）和能力约束（CRP）。

1、经营规划

定义

经营规划是企业最高层次的战略规划，通常在年度或季度层面制定。它主要回答以下问题：
- 企业的战略目标是什么？
- 未来1-3年的发展方向是什么？
- 大致需要多少资源？
内容要素
- 销售目标（总销售额、市场占有率）
- 财务目标（利润、现金流、投资回报率）
- 产能规划（是否需要新建工厂、购置设备）
- 产品规划（产品线调整、新产品开发）
输入与输出
- 输入：市场分析报告，输出：年度经营目标
- 输入：公司战略，输出：资源需求概算
- 输入：历史财务数据，输出：投资预算草案
在ERP中的体现

ERP系统中的经营规划通常不是由系统自动生成的，而是由高层管理者输入，作为下层计划的约束条件。例如：
- 在ERP中设置年度销售目标，作为销售预测的上限
- 在ERP中设置投资预算，作为采购和项目支出的控制线

2、销售与运作规划

定义

销售与运作规划（Sales & Operations Planning，S&OP）是连接战略规划与日常运作的桥梁，通常在月度层面滚动制定，是一个跨部门协同的过程。它主要回答以下问题：
- 未来3-18个月，每月需要生产多少产品？
- 产能是否匹配？
- 库存水平如何控制？
输出
- 需求计划：按产品族/类别的月度销售预测
- 供应计划：按产品族的月度生产计划
- 库存计划：目标库存水平
- 资源计划：人员、设备、资金的初步配置
在ERP中的体现

销售与运作规划在ERP系统中通常通过销售预测模块和粗能力计划（RCCP）实现：
- 销售预测：系统支持多种统计模型（移动平均、指数平滑、回归分析）
- 粗能力计划：粗略评估产能是否满足需求，若不足则提前预警

3、主生产计划

定义

主生产计划（Master Production Schedule，MPS）是ERP计划体系的核心引擎，是从宏观到微观的转折点。它主要回答：每一具体产品，在每一具体时间段（通常是周或日），生产多少？
基本概念
- 毛需求
  
  未考虑库存的原始需求，来自订单和预测。
- 计划接收
  
  已下达但尚未完工的订单，包括生产单和采购单。
- 预计可用库存
  
  预计的期末库存量（动态计算）。
- 净需求
  
  需要新安排生产的数量，等于：毛需求 - 可用库存 - 计划接收 + 安全库存。
- 计划产出
  
  计划生产出来的数量，通常等于净需求，但受批量规则影响。
- 计划投入
  
  开始生产的数量。
计算逻辑
- 第一步：确定毛需求
  - 近期：以订单为准
  - 中期：取订单和预测的大值
  - 远期：以预测为准
- 第二步：计算预计可用库存
  
  PABn = PABn-1 + SRn - GRn + PRn
- 第三步：计算净需求
  
  NRn = GRn - PABn-1 - SRn + 安全库存，若结果为负，取0。
- 第四步：确定计划产出
  
  PRn = NRn（但需考虑批量规则）
- 第五步：确定计划投入
  
  PORn = PRn（往前推提前期）
输入与输出
- 输入：客户订单，输出：各产品在各时段的生产计划
- 输入：销售预测，输出：计划产出量（完成时间）
- 输入：库存现状，输出：计划投入量（开始时间）
- 输入：提前期数据，输出：预计可用库存

4、物料需求计划

定义

物料需求计划（Material Requirements Planning，MRP）是MPS的向下展开，它要为MPS设计出一套与之配套的具体的物料供应计划。它主要回答以下问题：
- 为了完成MPS，需要哪些物料？
- 需要多少？什么时候需要？
核心逻辑

MPS（最终产品需求） ↓ ┌────┴────┐ ▼ ▼ 成品1 成品2 (BOM) (BOM) ↓ ↓ 零部件A 零部件B ↓ 原材料/外购件 ↓ 采购单/生产单 

输入与输出

输入：
- 主生产计划：生产什么？生产多少？
- 物料清单（BOM）：用什么材料？每件用多少？
- 库存记录：已经有什么？已经订了什么？
- 提前期：采购/生产需要多长时间？
输出：
- 采购计划：外购物料的采购单
- 生产计划：自制件的加工单
- 例外报告：提前期不足、需求异常等预警
主生产计划（MPS）
物料需求计划（MRP）
能力需求计划（CRP）

5、能力需求计划

定义

能力需求计划（Capacity Requirements Planning，CRP）是MRP的可行性检验，它主要回答以下问题：
- 计划所需的产能是否足够？
- 能力与负荷是否平衡？
能力计划方法
- 无限能力计划
  
  先不考虑能力约束，计划生成后再平衡；这种方式实现简单，但需人工反复调整。
  
  平衡方法：
```
 * 调整能力：加班、增加人员、外协 * 调整负荷：推迟生产、放弃订单、调整批量 
```
- 有限能力计划
  
  计划生成时即考虑能力约束；这种方式更切实际，但算法复杂。
  
  先进排程（Advanced Planning and Scheduling，APS）是实现有限能力计划的核心技术，它的核心思想是将时间、能力、负荷放在同一维度（时间轴）上，通过甘特图直观展示。
  
  它有两种基本排程方法：
```
 * 顺排法 从当前时刻开始，向后排程；它适合任务紧急，需要尽快完成的场景； * 倒排法 从交货期开始，向前排程。 
```
  - 关键步骤
    - 将任务按优先级排序（如交货期、先到先服务）
    - 确定关键路径（最长路径决定任务总时间）
    - 优先安排关键工序
    - 安排非关键工序（可顺排或倒排）
    - 处理资源冲突（后移任务）
    - 输出甘特图形式的生产计划
  - 优势
    - 自动平衡能力与负荷
    - 可视化展示
    - 快速响应变化

6、分销需求计划

定义

分销需求计划（Distribution Resource Planning，DRP）是面向分销网络的计划方法，它主要回答以下问题：
- 各分销节点需要多少产品？
- 何时需要？如何补货？
计算逻辑
```
 零售商需求 → 批发商需求 → 地区仓库需求 → 中心仓库需求 → 工厂MPS 
```
DRP与MRP逻辑相似，但方向相反：
- MRP：从产品树的主干向末梢展开
- DRP：从分销网络的末梢向主干归结
示例：
- 各零售商提交需求（毛需求）
- 考虑库存，计算各零售商的计划投入
- 汇总为批发商的毛需求
- 逐级向上，最终形成工厂的主生产计划

7、作业控制

生产作业控制

生产作业控制（Productive Activity Control，PAC）负责将计划转化为实际行动。
采购作业控制

采购作业控制（Purchase Order Control，POC）是对采购订单从创建到关闭的全流程跟踪、管理和优化的系列活动，以确保采购活动按计划执行。

四、核心模块

ERP的核心模块包括：销售管理、采购管理、库存管理、生产管理、质量管理、成本管理、财务管理和人力资源管理。

这六个模块并非独立运行，而是通过统一的数据平台和计划主线紧密集成，共同构成了ERP系统的整体。任何一个模块的数据变化，都会在其他模块中实时反映。

1、销售管理

销售管理是企业业务流程的起点和终点——从接到客户订单开始，到完成交付并收回货款结束。它是ERP系统中直接面向市场和客户的窗口。

它有以下核心功能：

销售预测

基于历史数据预测未来需求，支持多种统计模型（移动平均、回归分析等）；例如：根据过去3年同期销售数据预测旺季需求。
客户管理

维护客户档案、联系人、地址、信用额度、付款条件等；例如：记录北京XX公司的联系方式、信用额度10万元。
报价管理

根据成本模拟快速报价，并可预测最早交货期；例如：销售员录入订单后，系统自动计算最早6月12日可交货。
订单管理

订单录入、审核、跟踪、变更管理；例如：将客户100张方桌的意向转化为正式销售订单。
信用控制

订单生效前检查客户应收账款是否超限；例如：若客户欠款超信用额度，系统自动拦截订单。
交货处理

根据订单生成发货单、出库单，安排物流；例如：6月6日生成发货单，仓库据此发货。
销售分析

按产品、客户、区域等维度分析销售额、毛利、趋势；例如：分析哪些产品利润最高，哪些客户贡献最大。

2、采购管理

采购管理负责以“适时、适量、适质、适价”为目标，为生产提供所需物料。在ERP环境下，采购计划与生产计划紧密集成，改变了传统采购“各自为政”的局面。

它有以下核心功能：

供应商管理

建立供应商档案，记录资质、历史交易、评估结果；例如：为面板供应商A、面框供应商B建立档案。
采购计划生成

根据MRP结果自动生成采购建议；例如：系统计算出需采购面板90块、面框90个，建议批量采购100。
采购订单管理

采购订单下达、审批、打印、发送；例如：6月2日生成PO001和PO002采购单。
采购跟踪

跟踪订单执行状态，预警延期风险；例如：跟踪供应商A是否按时发货。
采购收货

核对采购订单，清点数量，办理入库；例如：6月7日收到面板100块，核对入库。
外协管理

管理外协加工业务（发料→加工→收料）；例如：若电镀工序外包，通过外协模块管理。
采购结算

与财务对接，处理发票、付款；例如：收到发票后，系统自动生成应付凭证。

3、库存管理

库存管理负责监控库存水平、控制库存成本、保证物料供应。ERP中的库存管理不仅是“记账”，更是实现库存优化和控制的核心手段。

它有以下核心功能：

物料主数据

维护物料代码、名称、计量单位、安全库存、批量规则等；例如：为方桌、桌面、桌腿、面板等建立物料主文件。
出入库管理

采购入库、生产入库、销售出库、生产领料、退货等；例如：6月7日面板入库，6月8日方桌成品入库。
库存移动

库位间调拨、待检区转移、车间退料等；例如：面板从待检区移入合格品区。
库存盘点

定期/循环盘点，调整账面与实物差异；例如：每月盘点，确保账实相符。
ABC分类管理

按库存价值将物料分为A、B、C三类，采取不同管理策略；例如：高价值的电机按A类管理，低价值的螺丝按C类管理。
安全库存管理

设置安全库存阈值，低于阈值自动报警；例如：面板安全库存设为20，低于时系统预警。

库存控制策略有以下几种：

经济订货批量（Economic Order Quantity）

平衡订购成本与持有成本，计算最优订货量。
ABC分类法

A类物料严控、小批量高频采购；C类物料宽松管理。
MRP控制

对相关需求物料，通过MRP精确计划补货时间和数量。

4、生产管理

生产管理负责将计划转化为实际产品，是ERP计划体系落地的执行层。其核心是“控制—反馈—调整”的闭环机制。

它有以下核心功能：

加工单管理

生成并下达生产单，包含加工数量、工艺路线、所需物料；例如：生成WO001（生产100个桌面）、WO002（生产400条桌腿）。
派工单管理

面向工作中心的作业指令，说明优先级、工序、工时；例如：向WC20下达“加工100块面板”的派工单。
生产发料

根据加工单需求，向仓库申请领料；例如：仓库根据生产单发放面板、面框、桌腿原材料。
工序反馈

操作员录入完工数量、工时、质量状态（劳务票）；例如：6月6日WC20完工100块面板，录入系统。
投入/产出控制

监控工作中心负荷，控制在制品数量（漏斗模型）；例如：监控WC10的待加工任务，避免堆积。

每个工作中心像一个“漏斗”，输入是下达的任务，输出是完成的产出。漏斗中的液体代表在制品。如果输入 > 输出，在制品增加，可能出现拥堵；如果输入 < 输出，在制品减少，可能出现闲置。通过控制输入和输出，可以保持生产节奏平稳。
生产完工入库

成品完工后办理入库，更新库存；例如：6月8日总装完成，方桌入库。

5、质量管理

质量管理贯穿企业生产经营全过程，ERP将质量管理与其他模块集成，实现全过程质量追溯和闭环控制。

它有以下核心功能：

质量标准管理

定义检验标准、缺陷等级、抽样方案、AQL值；例如：定义面板外观合格标准、尺寸公差范围。
进料检验

采购入库前检验，判定合格、退货或特采；例如：面板到货后，检验员抽检，合格后方可入库。
过程检验

生产过程中检验，防止不良品流入下道工序；例如：桌腿加工中检查尺寸是否合格。
成品检验

完工后检验，合格方可入库；例如：方桌组装完成后，检查平稳度、漆面。
质量控制

应用SPC控制图监控过程稳定性；例如：用控制图监控桌腿长度，及时发现异常。
质量分析

应用排列图、直方图等分析质量问题主因；例如：用排列图找出导致返工的主要缺陷类型。
不合格处理

不合格品评审、返工、报废、退货；例如：面板有划痕，判定为不合格，退回供应商。

6、成本管理

成本管理是ERP价值实现的核心——它将业务活动转化为财务语言，让管理者知道“赚了多少、亏在哪里”。它连接生产、采购、库存与财务，实现物流与资金流的统一。

成本构成：

产品成本 │ ├── 直接材料费 │ └── 原材料、外购件、辅助材料 │ ├── 直接人工费 │ └── 生产工人工资、奖金、津贴 │ └── 制造费用（间接成本） ├── 车间管理人员工资 ├── 设备折旧 ├── 水电费 ├── 维修费 └── 车间办公费 

它有以下核心功能：

成本类型管理

支持标准成本、实际成本、模拟成本三种类型；例如：年初制定标准成本，月底对比实际成本。
成本构成定义

定义直接材料、直接人工、制造费用的核算范围；例如：将工人工资归入直接人工，设备折旧归入制造费用。
直接材料费计算

根据BOM和材料单价累加计算；例如：方桌的面板、面框、桌腿材料费自动累加。
直接人工费计算

根据工艺路线和劳务票工时计算；例如：各工序工时 × 人工费率，自动汇总。
制造费用分配

按工时、人工费或机器工时分摊间接费用；例如：车间水电费按工时比例分摊到各产品。
标准成本与实际成本对比

计算成本差异，定位问题根源；例如：发现某物料采购价超标准10%，预警采购部门。
成本模拟

在报价或设计阶段模拟产品成本；例如：新产品报价前，快速估算成本。
成本报表

生成成本物料单、产品成本汇总表、差异分析表；例如：月底输出各产品成本明细。

成本有以下三种类型：

标准成本

预先确定的正常状态下的计划成本，用于：成本控制、差异分析、定价参考。
实际成本

生产过程中实际发生的成本，用于：财务报表、存货计价。
模拟成本

基于假设条件计算的可能成本，用于：报价决策、产品设计优化。

7、财务管理

财务管理是ERP集成效果的最终体现——它将业务活动实时转化为资金信息，实现物流与资金流的同步，是ERP区别于传统会计电算化的本质特征。

它有以下核心功能：

总账管理

会计科目设置、凭证管理、账簿查询；例如：设置“原材料”“应付账款”“库存商品”等科目。
应收账款

客户发票、收款、账龄分析、坏账管理；例如：销售发票生成时自动记入应收账款。
应付账款

供应商发票、付款、账龄管理；例如：采购入库时自动记入应付账款。
固定资产

固定资产卡片、折旧计提、增减管理；例如：机器设备折旧按月计提，计入制造费用。
成本管理

直接材料、直接人工、制造费用的归集与分配；例如：方桌生产成本 = 面板 + 面框 + 桌腿材料费 + 人工费 + 分摊制造费用。

财务报表

自动生成资产负债表、利润表、现金流量表；例如：月底系统自动生成三大报表。

成本构成与计算：

产品成本要素
- 直接材料费：生产产品消耗的原材料成本（面板、面框、桌腿原材料）。
- 直接人工费：生产人员工资、奖金。
- 制造费用：折旧、水电、车间管理人员工资等间接费用。
成本计算方法
- 直接材料费：= 物料用量 × 材料单价（采用先进先出、加权平均等方法）
- 直接人工费：= 工序工时 × 工作中心人工费率
- 制造费用按工时比例分摊到产品

物流与资金流的同步：

ERP与传统会计电算化的本质区别：业务单据驱动会计凭证自动生成，这意味着财务人员不再需要重复录入业务数据，凭证由业务系统自动生成，财务信息的实时性和准确性得到根本保障。

业务单据	自动生成的会计分录
采购入库单	借：原材料 / 贷：应付账款
生产领料单	借：生产成本 / 贷：原材料
工序完工报告	借：生产成本 / 贷：应付职工薪酬、制造费用
成品入库单	借：库存商品 / 贷：生产成本
销售出库单	借：主营业务成本 / 贷：库存商品
销售发票	借：应收账款 / 贷：主营业务收入、应交税费
收款单	借：银行存款 / 贷：应收账款

以第一行为例，表示一个完整的“采购收货”业务闭环：

场景

公司向供应商采购的原材料到货，仓库人员验收后，在系统中根据采购订单生成或审核一张采购入库单。这张单据统计了实际收到了什么货、收到了多少。
财务影响

系统在采购入库单过账的瞬间，会自动生成以下会计分录：

借：原材料：表示公司的存货（原材料）增加了；这是资产的增加，记在借方。

贷：应付账款：表示公司因为收到了这批货，对供应商产生了付款义务（欠款）；这是负债的增加，记在贷方。

这个过程体现了“账实相符”和“业务驱动财务”的原则。

8、人力资源管理

人力资源管理（HRM）是ERP系统中管人的模块，它管理企业最重要的资源：人。虽然ERP起源于制造业，但现代ERP已将人力资源管理纳入核心功能，支持从招聘到退休的全生命周期管理。

它有以下核心功能：

组织管理

维护部门架构、岗位设置、编制管理；例如：设立生产部、销售部、财务部，定义各部门岗位。
员工信息管理

员工档案、合同、学历、职称、履历；例如：记录员工基本信息、入职时间、劳动合同到期日。
招聘管理

招聘计划、简历筛选、面试安排、录用审批；例如：发布招聘需求，跟踪应聘者状态。
考勤管理

排班、打卡、请假、出差、加班统计；例如：一线工人排班，记录迟到早退，计算加班工时。
薪酬管理

工资计算、个税申报、社保公积金、工资条发放；例如：根据考勤和绩效计算月薪，自动生成工资表。
绩效管理

绩效考核方案、考核打分、绩效面谈、结果应用；例如：季度KPI考核，结果与奖金挂钩。
培训管理

培训计划、课程安排、培训记录、证书管理；例如：组织ERP系统操作培训，记录员工培训学时。
员工发展

职业规划、晋升管理、继任计划；例如：识别高潜力员工，规划晋升路径。
离职管理

离职申请、离职面谈、工作交接、离职手续；例如：员工离职流程审批，自动触发权限回收。

参考资料

《ERP简明教程》

TypeScript简介

2026-01-17T00:00:00+08:00

一、简介

TypeScript是JavaScript的一个超集，在标准JavaScript的基础上添加了静态类型系统。它有

1、特性

静态类型检查

在编写代码时可以为变量、函数参数、返回值等显式地声明数据类型（如string、number、boolean以及自定义接口interface或类class等）。

使用静态类型检查可以在编译阶段就能检查出类型不匹配的错误，减少运行时错误，提高代码的健壮性，增强代码可读性。

面向对象编程增强

TypeScript原生支持并扩展了ES6的类（class）、接口（interface）、继承（extends）、访问修饰符（public、private、protected）等面向对象概念。

2、工作原理

使用npm install -g typescript安装TypeScript
编写TypeScript文件，以.ts命名
使用TypeScript编译器(tsc)将.ts文件转换成.js文件
运行编译生成后的*.js文件

3、Hello World

hello.ts

const message:string = "Hello World!"; console.log(message); 

编译

tsc hello.ts

生成hello.js：

var message = "Hello World!"; console.log(message); 

运行

运行编译生成后的hello.js:

node hello.js

输出：

Hello World!

4、配置

tsconfig.json是每个TypeScript项目的核心文件，它告诉TypeScript编译器如何处理你的代码，包含哪些文件，以及启用或禁用哪些功能等。可以通过tsc --init生成tsconfig.json文件。

主要的配置项如下：

compilerOptions

控制TypeScript如何编译代码。

include

配置用于编译的文件或文件夹。

exclude

配置需要排除的文件或文件夹。

files

明确列出需要包含的文件。

extends

继承另一个配置文件中的配置。

例如：

{ "compilerOptions": { "target": "es2020", "module": "esnext", "strict": true, "baseUrl": ".", "paths": { "@app/*": ["src/app/*"] }, "outDir": "dist", "esModuleInterop": true }, "include": ["src"], "exclude": ["node_modules", "dist"] } 

二、语法

1、简单类型

Boolean

let isActive: boolean = true; let hasPermission = false; 

Number

表示整数和浮点数。

let decimal: number = 6; //16进制 let hex: number = 0xf00d; //2进制 let binary: number = 0b1010; //8进制 let octal: number = 0o744; let float: number = 3.14; 

String

let color: string = "blue"; let fullName: string = 'John Doe'; let age: number = 30; let sentence: string = `Hello, my name is ${fullName} and I'll be ${age + 1} next year.`; console.log(sentence); 

输出：

Hello, my name is John Doe and I'll be 31 next year.

BigInt

使用n作为后缀，表示大于2的53次方减1的整数。

const bigNumber: bigint = 9007199254740991n; const hugeNumber = BigInt(9007199254740991); 

Symbol

通常用于创建唯一的属性键和常量。

const uniqueKey: symbol = Symbol('description'); const obj = { [uniqueKey]: 'This is a unique property' }; console.log(obj[uniqueKey]); 

使用tsc hello.ts --target es2016编译后运行，输出：

This is a unique property

2、特殊类型

any类型是TypeScript中最灵活的类型，本质上是告诉编译器跳过某个特定变量的类型检查。但应谨慎使用，因为它绕过了TypeScript的类型安全特性。

let u = true; u = "string"; Math.round(u); 

编译时报错：

error TS2322: Type 'string' is not assignable to type 'boolean'. u = "string"; error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'number'. Math.round(u); 

将变量设置为any类型会禁用类型检查：

let v: any = true; v = "string"; Math.round(v); 

可以成功编译。

unknown

unknown是类型安全的any，意思是“这可能是任何东西，所以你必须在使用前进行某种检查”。

任何值都可以赋给unknown：

let userInput: unknown; userInput = 42; userInput = true; userInput = [1, 2, 3]; userInput = "Hello, World!"; 

使用unknown时必须先进行类型检查，如果直接使用：

console.log(userInput.length);

编译时会提示：

error TS2339: Property 'length' does not exist on type 'unknown'

需要增加类型检查：

if (typeof userInput === "string") { console.log(userInput.length); } 

never

never表示那些永远不会出现的值类型，例如：下面的函数总是抛出错误永不返回：

function throwError(message: string): never { throw new Error(message); } 

3、类型推断

TypeScript可以根据变量的初始值自动确定（推断）其类型：

let username = "alice"; let score = 100; //推断类型为布尔数组 let flags = [true, false, true]; //推断返回值类型为数值 function add(a: number, b: number) { return a + b; } 

对象字面量推断

const user = { name: "Alice", age: 30, isAdmin: true }; //推断属性是否存在 console.log(user.name); console.log(user.email);//Error 

编译时会出现错误：

error TS2339: Property 'email' does not exist on type '{ name: string; age: number; isAdmin: boolean; }'. 

无法推断类型

// Type is 'any' let something; something = 'hello'; something = 42; 

无法确定正确的类型时，TypeScript会退回到any类型，从而禁用类型检查。

4、显式类型

使用显式类型可以明确声明变量的类型，通常用于：函数参数与返回值类型、对象字面量以及当初始值可能不是最终类型时。

基本类型

// String const greeting: string = "Hello, TypeScript!"; // Number const userCount: number = 42; // Boolean const isLoading: boolean = true; // Array of numbers const scores: number[] = [100, 95, 98]; 

类型不匹配

显式类型不匹配：

let username: string = "alice"; username = 42;//Error: Type 'number' is not assignable to type 'string' 

隐式类型不匹配：

let score = 100; score = "high";//Error: Type 'string' is not assignable to type 'number' 

函数

function greet(name: string): string { return `Hello, ${name}!`; } //调用函数时会确保参数类型正确 greet("Alice"); greet(42); //Error 

编译时会出现错误：

error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'. 

5、数组

const names: string[] = []; names.push("Dylan"); //类型检查，编译会报错 names.push(3); 

readonly

使用readonly可以阻止数组被修改：

const names: readonly string[] = ["Dylan"]; names.push("Jack"); 

编译时报错：

error TS2339: Property 'push' does not exist on type 'readonly string[]'.

6、元组

元组是一个带有预定义长度和每个索引类型的数组，它允许数组中的每个元素都是已知的值类型。

let ourTuple: [number, boolean, string]; ourTuple = [5, false, 'Coding God was here']; 

readonly

也可以通过readonly设置为只读：

const ourReadonlyTuple: readonly [number, boolean, string] = [5, true, 'The Real Coding God']; ourReadonlyTuple.push('Coding God took a day off'); 

编译时会出错：

error TS2339: Property 'push' does not exist on type 'readonly [number, boolean, string]'. 

命名元组与结构化

可以为每个索引命名：

const graph: [x: number, y: number] = [55.2, 41.3]; const [x,y] = graph; console.log(x);//55.2 console.log(y);//41.3 console.log(graph[0]);//55.2 

7、对象类型

示例

const car: { type: string, model: string, year: number } = { type: "Toyota", model: "Corolla", year: 2009 }; 

类型推断

const car = { type: "Toyota", }; car.type = "Ford"; car.type = 2;//Error 

编译时报错：

error TS2322: Type 'number' is not assignable to type 'string'.

可选属性

下面例子中mileage为可选属性：

const car: { type: string, mileage?: number } = { type: "Toyota" }; car.mileage = 2000; 

如果不设置可选，则在编译时会报错：

const car: { type: string, mileage: number } = { type: "Toyota", }; car.mileage = 2000; 

hello.ts:1:7 - error TS2741: Property 'mileage' is missing in type '{ type: string; }' but required in type '{ type: string; mileage: number; }'. 

索引签名

索引签名可用于没有定义属性列表的对象：

const nameAgeMap: { [index: string]: number } = {}; nameAgeMap.Jack = 25; nameAgeMap.Mark = "Fifty";//Error 

指定了索引类型和值类型，上面示例在编译时报错：

 error TS2322: Type 'string' is not assignable to type 'number'.

8、枚举

枚举有两种类型：字符串(string)和数值(numeric)。

默认情况下，枚举会将第一个值初始化为0，并在每个新增值上加1：

enum CardinalDirections { North, East, South, West } console.log(CardinalDirections.North); console.log(CardinalDirections.South); 

输出：

0 2

初始化

以设置第一个数值枚举的值，后面的值依次递增：

enum CardinalDirections { North = 10, East, South, West } console.log(CardinalDirections.North); console.log(CardinalDirections.South); 

输出：

10 12

完全初始化

可以为每个枚举值分配独特的数字值：

enum StatusCodes { NotFound = 404, Success = 200, Accepted = 202, BadRequest = 400 } console.log(StatusCodes.NotFound); console.log(StatusCodes.Success); 

输出：

404 200

字符串枚举

enum CardinalDirections { North = 'N', East = "E", South = "S", West = "W" }; console.log(CardinalDirections.North); console.log(CardinalDirections.West); 

输出：

N W

9、类型别名

允许用自定义名称（别名）定义类型：

//定义类型别名 type Year = number type CarType = string type CarModel = string type Car = { year: Year, type: CarType, model: CarModel } //使用别名定义变量类型 const carYear: Year = 2001 const carType: CarType = "Toyota" const carModel: CarModel = "Corolla" const car: Car = { year: carYear, type: carType, model: carModel }; 

10、接口

interface Rectangle { height: number, width: number } const rectangle: Rectangle = { height: 20, width: 10 }; 

接口合并

interface Animal { name: string; } interface Animal { age: number; } const dog: Animal = { name: "Fido", age: 5 }; console.log(dog.name); console.log(dog.age); 

输出：

Fido 5

接口继承

interface Rectangle { height: number, width: number } interface ColoredRectangle extends Rectangle { color: string } const cr: ColoredRectangle = { height: 20, width: 10, color: "red" }; console.log(cr.height); console.log(cr.width); console.log(cr.color); 

输出：

20 10 red

11、类

TypeScript为JavaScript类添加了类型和可见性修饰符。

成员类型

类的成员（属性和方法）通过类型注释进行类型化，类似于变量：

class Person { name: string; } const person = new Person(); person.name = "Jane"; 

可见性

class Person { private name: string; public constructor(name: string) { this.name = name; } public getName(): string { return this.name; } } const person = new Person("Jane"); console.log(person.getName()); //Jane 

参数属性

TypeScript在参数中添加可见性修饰符：

class Person { //name为私有变量 public constructor(private name: string) {} public getName(): string { return this.name; } } const person = new Person("Jane"); console.log(person.getName());//Jane 

只读

使用readonly可以防止类成员被修改：

class Person { private readonly name: string; public constructor(name: string) { //name属性赋值后不允许被修改 this.name = name; } public getName(): string { return this.name; } } 

实现接口

interface Shape { getArea(): number; } class Rectangle implements Shape { public constructor(protected readonly width: number, protected readonly height: number) { } public getArea() : number { return this.width * this.height; } } 

继承类

class Square extends Rectangle { public constructor(width: number) { super(width, width); } } 

覆盖

继承时可以使用相同名称的成员替换父类的成员：

class Square extends Rectangle { public constructor(width: number) { super(width, width); } public override getArea(): number { return this.width * this.width; } } 

抽象类

可以使用abstract将类定义为抽象类，类中未实现的成员也使用abstract关键词修饰；抽象类无法直接实例化。

abstract class Polygon { public abstract getArea(): number; public toString(): string { return `Polygon[area=${this.getArea()}]`; } } class Rectangle extends Polygon { public constructor(protected readonly width: number, protected readonly height: number) { super(); } public getArea(): number { return this.width * this.height; } } 

12、或类型

当一个值是多个类型时，可以使用联合(或)类型|。

例如，下面的例子中参数是string或number类型：

function printStatusCode(code: string | number) { console.log(`My status code is ${code}.`) } printStatusCode(404); printStatusCode('404'); 

输出：

My status code is 404. My status code is 404.

类型错误

使用|类型时，需要避免类型错误：

function printStatusCode(code: string | number) { console.log(`My status code is ${code.toUpperCase()}.`); } 

编译时报错：

error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. Property 'toUpperCase' does not exist on type 'number'. 

13、函数

返回值类型

可以明确定义函数的返回值类型：

function getTime(): number { return new Date().getTime(); } 

返回空类型

function printHello(): void { console.log('Hello!'); } 

参数

函数参数的类型与变量声明的语法类似：

function multiply(a: number, b: number) { return a * b; } 

可选参数

function add(a: number, b: number, c?: number) { return a + b + (c || 0); } 

默认参数

function pow(value: number, exponent: number = 10) { return value ** exponent; } 

命名参数

function divide({ dividend, divisor }: { dividend: number, divisor: number }) { return dividend / divisor; } 

剩余参数

剩余参数可以将一个不定数量的参数表示为一个数组，它必须是函数参数列表中的最后一个参数。

function add(a: number, b: number, ...rest: number[]) { return a + b + rest.reduce((p, c) => p + c, 0); } 

14、类型断言

有时处理类型时需要覆盖变量的类型，可以使用as关键字改变变量的类型：

let x: unknown = 'hello'; console.log((x as string).length);//5 

但并不会改变变量值数据的类型：

let x: unknown = 4; console.log((x as string).length); 

由于值是数值类型，因此输出undefined。

也可以用<>，和as效果一样：

let x: unknown = 'hello'; console.log((<string>x).length); 

为了避免TypeScript在覆盖类型时可能抛出的类型错误，可以先将类型改为unknown，然后再改为目标类型：

let x = 5; console.log(((x as unknown) as string).length); 

输出：undefined

15、泛型

函数

带有泛型的函数可以创建更通用的函数：

function createPair<S, T>(v1: S, v2: T): [S, T] { return [v1, v2]; } console.log(createPair<string, number>('hello', 42)); 

输出：

[ 'hello', 42 ]

泛型可以被赋予默认值，如果没有指定或推断其他值，则使用默认值：

class NamedValue<T = string> { private _value: T | undefined; constructor(private name: string) {} public setValue(value: T) { this._value = value; } public getValue(): T | undefined { return this._value; } public toString(): string { return `${this.name}: ${this._value}`; } } let value = new NamedValue('myKey'); value.setValue('myValue'); console.log(value.toString()); 

输出：

myKey: myValue

继承

<S extends Shape | Animal>

16、keyof

提取键类型

keyof可以从对象类型中提取键类型：

interface Person { name: string; age: number; } function printPersonProperty(person: Person, property: keyof Person) { console.log(`Printing person property ${property}: "${person[property]}"`); } let person = { name: "Max", age: 27 }; printPersonProperty(person, "name"); 

输出：

Printing person property name: "Max"

提取索引类型

keyof也可以与索引签名一起使用提取索引类型：

type StringMap = { [key: string]: unknown }; function createStringPair(property: keyof StringMap, value: string): StringMap { return { [property]: value }; } console.log(createStringPair('myKey', 'myValue')); 

输出：

{ myKey: 'myValue' }

17、类型/属性检查

typeof

typeof可以在运行时检查原始值的类型。

function formatValue(value: string | number): string { if (typeof value === 'string') { return value.trim().toUpperCase(); } else { return value.toFixed(2); } } console.log(formatValue(' hello ')); console.log(formatValue(56.1234)); 

输出：

HELLO 56.12

instanceof

instanceof可以检查对象是否是特定类或构造函数的实例。

class Bird { fly() { console.log("Flying..."); } } class Fish { swim() { console.log("Swimming..."); } } function move(animal: Bird | Fish) { if (animal instanceof Bird) { animal.fly(); } else { animal.swim(); } } move(new Bird()); move(new Fish()); 

输出：

Flying... Swimming...

in可以检查对象上是否存在属性。

interface Dog { bark(): void; } interface Cat { meow(): void; } function makeSound(animal: Dog | Cat) { if ("bark" in animal) { animal.bark(); } else { animal.meow(); } } const myDog: Dog = { bark: () => { console.log("Woof! Woof!"); } }; const myCat: Cat = { meow: () => { console.log("Meow! Meow!"); } }; makeSound(myDog); makeSound(myCat); 

输出：

Woof! Woof! Meow! Meow!

18、工具类型

Partial

Partial将对象中的所有属性改为可选。

interface Point { x: number; y: number; } //x和y可选 let pointPart: Partial<Point> = {}; pointPart.x = 10; 

Required

Required可以将对象中的所有属性改为必须：

interface Car { make: string; model: string; mileage?: number; } let myCar: Required<Car> = { make: 'Ford', model: 'Focus', mileage: 12000 // `Required` }; 

Record

可以通过Record定义具有特定键类型和值类型的对象：

const nameAgeMap: Record<string, number> = { 'Alice': 21, 'Bob': 25 }; 

Omit

Omit可以移除对象类型的键。

interface Person { name: string; age: number; location?: string; } const bob: Omit<Person, 'age' | 'location'> = { name: 'Bob' }; 

上面bob只能定义name，其他两个属性已被移除。

Pick

Pick可以移除对象类型中除指定键外的其他键。

interface Person { name: string; age: number; location?: string; } const bob: Pick<Person, 'name'> = { name: 'Bob' }; 

上面通过Pick只保留了name属性。

Exclude

Exclude从并集中移除类型。

type Primitive = string | number | boolean const value: Exclude<Primitive, string> = true; const num : Exclude<Primitive, string> = 123; 

上面例子中Exclude<Primitive, string>表示在Primitive类型中移除string，因此只能定义为boolean或number类型。

ReturnType

ReturnType可以提取函数的返回类型。

type PointGenerator = () => { x: number; y: number; }; const point: ReturnType<PointGenerator> = { x: 10, y: 20 }; 

Parameters

提取函数的参数类型，值为数组形式。

type PointPrinter = (p: { x: number; y: number; }) => void; const point: Parameters<PointPrinter>[0] = { x: 10, y: 20 }; 

Readonly

Readonly可以创建一个新类型，其中所有属性都是只读的，一旦赋值就无法修改。

interface Person { name: string; age: number; } const person: Readonly<Person> = { name: "Dylan", age: 35, }; person.name = 'Israel'; 

会出现编译错误：

error TS2540: Cannot assign to 'name' because it is a read-only property.

参考资料：

TypeScript Getting Started

hashCode引起的性能问题

2025-12-06T00:00:00+08:00

一、场景

1、概述

业务中存在多张单下推生成另一张单的场景，而且单据量比较大，此时通过目标单获取源单时会比较慢。

2、Java类

数据类：

public class Data { private Long tableId; private Long billId; public Data(Long tableId, Long billId) { super(); this.tableId = tableId; this.billId = billId; } public Long getTableId() { return tableId; } public void setTableId(Long tableId) { this.tableId = tableId; } public Long getBillId() { return billId; } public void setBillId(Long billId) { this.billId = billId; } @Override public int hashCode() { int hashCode = 31 * this.tableId.hashCode(); hashCode = 31 * hashCode + this.billId.hashCode(); return hashCode; } @Override public boolean equals(Object obj) { if(!(obj instanceof Data)) { return false; } Data other = (Data) obj; return this.tableId.equals(other.getTableId()) && this.billId.equals(other.getBillId()); } } 

关系类：

public class DataRelation { private Data data; private Data source; public Data getData() { return data; } public void setData(Data data) { this.data = data; } public Data getSource() { return source; } public void setSource(Data source) { this.source = source; } @Override public int hashCode() { int hashcode = 31 * (this.source == null ? 1 : this.source.hashCode()); hashcode = 31 * (this.data == null ? 1 : this.data.hashCode()); return hashcode; } @Override public boolean equals(Object obj) { if(!(obj instanceof DataRelation)) { return false; } DataRelation other = (DataRelation) obj; return this.dataEquals(this.source, other.getSource()) && this.dataEquals(this.data, other.getData()); } private boolean dataEquals(Data data, Data other) { return data == null && other == null ? true : (data != null && other != null ? data.equals(other) : false); } } 

模拟的数据查询返回记录类：

public class Row { private Long srcTableId; private Long srcBillId; private Long tgtTableId; private Long tgtBillId; public Row(Long srcTableId, Long srcBillId, Long tgtTableId, Long tgtBillId) { super(); this.srcTableId = srcTableId; this.srcBillId = srcBillId; this.tgtTableId = tgtTableId; this.tgtBillId = tgtBillId; } public Long getSrcTableId() { return srcTableId; } public void setSrcTableId(Long srcTableId) { this.srcTableId = srcTableId; } public Long getSrcBillId() { return srcBillId; } public void setSrcBillId(Long srcBillId) { this.srcBillId = srcBillId; } public Long getTgtTableId() { return tgtTableId; } public void setTgtTableId(Long tgtTableId) { this.tgtTableId = tgtTableId; } public Long getTgtBillId() { return tgtBillId; } public void setTgtBillId(Long tgtBillId) { this.tgtBillId = tgtBillId; } } 

查询关系工具类：

public class BillTrackUtil { public static Set<DataRelation> getRelationByTgtBillId(Long tgtBillId) { Set<DataRelation> result = new HashSet<>(); //查询源单 List<Row> rows = querySourceBill(tgtBillId); Long start = System.currentTimeMillis(); for(Row row : rows) { Data source = new Data(row.getSrcTableId(), row.getSrcBillId()); Data target = new Data(row.getTgtTableId(), row.getTgtBillId()); DataRelation relation = new DataRelation(); relation.setData(target); relation.setSource(source); result.add(relation); } Long end = System.currentTimeMillis(); System.out.println("cost: " + (end - start)); return result; } private static List<Row> querySourceBill(Long tgtBillId){ //模拟从数据库查询 SELECT FSTableId, FSBillId, FTTableId, FTBillId FROM XXX WHERE FTBillId = xxx List<Row> rows = new ArrayList<>(); Long tgtTableId = 5001L; Long srcTableId = 1001L; Long srcBillId = 20000001L; for(int i = 1; i <= 50000; i++) { if(i % 1000 == 0) { srcTableId++; } srcBillId ++; Row row = new Row(srcTableId, srcBillId, tgtTableId, tgtBillId); rows.add(row); } return rows; } } 

3、运行

调用工具类获取某张单据的所有源单：

Long tgtBillId = 60000001L; Set<DataRelation> ret = BillTrackUtil.getRelationByTgtBillId(tgtBillId); ... 

上面模拟了5万张源单，耗时：66538ms，大概1分钟。

二、分析及处理

分析

使用jvisualvm分析耗时：

可以看到，主要消耗在HashSet的add方法。

原因

DataRelation类的hashCode方法有问题，此种场景下计算出来的hashCode都是相同的，导致哈希冲突。

处理方式

修改DataRelation类的hashCode方法为如下：

public int hashCode() { int hashcode = 31 * (this.source == null ? 1 : this.source.hashCode()); hashcode = 31 * hashcode + (this.data == null ? 1 : this.data.hashCode()); return hashcode; } 

再次运行，仅耗时21ms。

三、哈希码计算方式

常用的哈希码计算方式如下：

官方模板

public int hashCode() { //可变参数，内部就是 31乘加 链 return Objects.hash(field1, field2, field3); } 

“31乘加”链

public int hashCode() { //初始值非0即可，31是奇素数，且JVM会把 *31 优化成 (i<<5)-i，几乎无代价 int result = 31; result = 31 * result + field1.hashCode(); result = 31 * result + (field2 == null ? 0 : field2.hashCode()); return result; } 

VNT组网

2025-11-08T00:00:00+08:00

一、简介

VNT（Virtual Network Tool）是一款开源的虚拟网络工具，用于实现异地组网和内网穿透，能将不同地点的设备连接到同一个虚拟局域网中。它具备以下主要特点：

开源与跨平台
高效组网

采用点对点（P2P）技术，优先尝试在设备间建立直接连接；当直连不可行时（会自动使用中继服务器转发数据，以确保连接成功

简单易用

可以通过命令行进行配置，只需设置一个共享的令牌（token），即可让不同设备加入同一虚拟网络

二、安装

下载VNT并解压
Windows默认使用tun网卡，需要下载wintun.dll并和vnt工具放在同一目录

三、常用命令

-k <token>

组网的唯一标识，使用相同的token，就能组建一个局域网络；

-n <name>

设备名称，便于区分不同设备，默认使用系统版本；

-w <password>

运行vnt-cli时使用该密码生成的密钥对客户端数据进行加密，并且（中继）服务端无法解密，使用相同密码的客户端才能通信。

-s <server>

指定中继服务器地址，协议支持使用tcp://和ws://和wss://，默认为udp://。

--ip

指定虚拟ip，指定的ip不能和其他设备重复，必须有效并且在服务端所属网段下，默认由服务端分配；必须与另一端电脑命令中-i参数里指定的对端虚拟IP一致；

-i <in-ip>

配置点对网时使用，-i 192.168.0.0/24,10.26.0.3表示允许接收网段192.168.0.0/24的数据并转发到10.26.0.3（即如果想访问192.168.0.0/24这个网段，需要把数据包发给虚拟IP为10.26.0.3的节点），可指定多个网段；

-o <out-ip>

配置点对网时使用，宣告本机所在的物理网络段，-o 192.168.0.0/24表示允许将数据转发到192.168.0.0/24，可指定多个网段；

--info

后台运行时，查看当前设备信息。

--list

后台运行时，查看其他设备列表。

四、组网

假设家庭电脑的ip地址为：172.16.0.13，公司电脑的ip地址为：172.27.160.52。

1、双向组网

通过vnt-cli将位于不同内网的家庭和公司电脑连接到同一个虚拟局域网中来实现双向互访（网对网）；例如，指定公司电脑虚拟ip为10.26.0.3，指定家庭电脑虚拟ip为10.26.0.2。

在公司电脑上运行：

vnt-cli -k 5F9DE3948546A0A5CB -w A1Q2P3M4 -n company-pc --ip 10.26.0.3 -i 172.16.0.0/24,10.26.0.2 -o 172.27.160.0/24 

在家庭电脑上运行：

vnt-cli -k 5F9DE3948546A0A5CB -w A1Q2P3M4 -n home-pc --ip 10.26.0.2 -i 172.27.160.0/24,10.26.0.3 -o 172.16.0.0/24 

执行完命令后即可完成虚拟局域网的搭建，可以看到会创建一个vnt-tun的网络连接。

参数说明：

-k <token>

组网的唯一标识，使用相同的token，就能组建一个局域网络；

-n <name>

设备名称，便于区分不同设备，默认使用系统版本；

--ip

-i <in-ip>

配置点对网(IP代理)时使用，-i 192.168.0.0/24,10.26.0.3表示允许接收网段192.168.0.0/24的数据并转发到10.26.0.3，可指定多个网段；

例如公司电脑命令中的-i 172.16.0.0/24,10.26.0.2可以解释为：如果想访问172.16.0.0/24这个网段（家庭电脑所在的局域网），需要把数据包发给虚拟IP为10.26.0.2的节点（家庭电脑）。

-o <out-ip>

配置点对网时使用，宣告本机所在的物理网络段，-o 192.168.0.0/24表示允许将数据转发到192.168.0.0/24，可指定多个网段；

访问多个网段

如果需要访问公司其他网段的服务，例如192.168.36.05的服务，需要修改vnt-cli命令：

公司电脑增加-o参数指定192.168.36.0网段：

vnt-cli -k 5F9DE3948546A0A5CB -w A1Q2P3M4 -n company-pc --ip 10.26.0.3 -i 172.16.0.0/24,10.26.0.2 -o 172.27.160.0/24 -o 192.168.36.0/24 

家庭电脑增加-i参数指定192.168.36.0网段：

vnt-cli -k 5F9DE3948546A0A5CB -w A1Q2P3M4 -n home-pc --ip 10.26.0.2 -i 172.27.160.0/24,10.26.0.3 -i 192.168.36.0/24,10.26.0.3 -o 172.16.0.0/24 

2、单向组网

如果只需要在家单向访问公司网络（点对网），命令如下：

在公司电脑上运行：

vnt-cli -k 5F9DE3948546A0A5CB -w A1Q2P3M4 -n company-pc --ip 10.26.0.3 -o 172.27.160.0/24 

在家庭电脑上运行：

vnt-cli -k 5F9DE3948546A0A5CB -w A1Q2P3M4 -n home-pc --ip 10.26.0.2 -i 172.27.160.0/24,10.26.0.3 

五、问题及解决方式

1、远程主机强迫关闭了一个现有的连接

运行vnt-cli --list报错：

cmd: Os { code: 10054, kind: ConnectionReset, message: "远程主机强迫关闭了一个现有的连接。" } 

解决方式

需要在vnt-cli运行时执行

2、一直输出connect

解决方式

由于在vnt-cli命令中指定了中继服务器（-s xxx），使用默认服务器或更换其他中继服务器即可。

3、连接成功但ping不通

使用双向组网连接成功，且通过vnt-cli --list可以看到虚拟局域网中的设备，但是通过虚拟ip均无法ping通。

ping 10.26.0.2：

正在 Ping 10.26.0.2 具有 32 字节的数据: 请求超时。 请求超时。 

使用tracert 10.26.0.2也是超时：

通过最多 30 个跃点跟踪到 10.26.0.2 的路由 1 * * * 请求超时。 2 * * * 请求超时。 

使用arp -a看到接口: 10.26.0.3 --- 0x22下的物理地址均为空：

解决方式

更换vnt版本，使用稳定版重新连接即可（之前下载的是预发布版本）。

参考资料：

Feign简介

2025-10-19T00:00:00+08:00

一、简介

Feign是一个由Netflix开源的声明式HTTP客户端框架，旨在简化Web服务客户端的开发。通过抽象化模板代码，Feign让开发者能够以更简洁、更直观的方式编写REST API调用。

二、原生Feign样例

1、注解

@RequestLine

@RequestLine是原生Feign核心库中用于定义HTTP请求的关键注解，它提供了一种更接近于底层HTTP协议的、声明式的方式来指定请求方法（GET, POST 等）和路径；它的核心作用是将接口方法映射到具体的HTTP请求。

@RequestLine注解的值是一个字符串，标准格式为：”HTTP_METHOD URI_TEMPLATE”，其中：
- HTTP_METHOD：请求方法，例如 GET, POST, PUT, DELETE, HEAD等。
- URI_TEMPLATE：请求路径，可以包含占位符（如{id}）来动态替换参数。
@Param

使用@Param注解显式标记方法参数，并指定在URI模板或头信息中对应的占位符名称。

举例：

简单的GET请求，无参数：

@RequestLine("GET /books") List<Book> findAll();

路径中包含参数的GET请求：

@RequestLine("GET /books/{isbn}") Book findByIsbn(@Param("isbn") String isbn);

路径和查询参数结合使用：

@RequestLine("GET /books?author={author}&title={title}") List<Book> findBooksByAuthorAndTitle(@Param("author") String author, @Param("title") String title); 

POST请求，需指定Content-Type头信息：

@RequestLine("POST /book") @Headers("Content-Type: application/json") void create(Book book); 

2、样例

数据源

此处使用jsonplaceholder提供的todos数据：

https://jsonplaceholder.typicode.com/todos返回200个待办事项，结构如下：

[ { "userId": 1, "id": 1, "title": "delectus aut autem", "completed": false }, { "userId": 1, "id": 2, "title": "quis ut nam facilis et officia qui", "completed": false }, { "userId": 1, "id": 3, "title": "fugiat veniam minus", "completed": false }, ... ] 

可以在请求中增加todo的id获取指定的待办事项：https://jsonplaceholder.typicode.com/todos/5

{ "userId": 1, "id": 5, "title": "laboriosam mollitia et enim quasi adipisci quia provident illum", "completed": false } 

依赖

pom.xml中依赖如下：

<dependencies> <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-okhttp</artifactId> <version>13.1</version> </dependency> <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-gson</artifactId> <version>13.1</version> </dependency> <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-slf4j</artifactId> <version>13.1</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.13</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.32</version> </dependency> </dependencies> 

日志配置

src/main/resource/logback.xml：

<configuration> <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern> </encoder> </appender> <root level="DEBUG"> <!-- 根据需要调整根日志级别，如 INFO 或 WARN --> <appender-ref ref="CONSOLE" /> </root> </configuration> 

模型类

Todo.java：

public class Todo { private int id; private int userId; private String title; private boolean completed; public int getId() { return id; } public void setId(int id) { this.id = id; } public int getUserId() { return userId; } public void setUserId(int userId) { this.userId = userId; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public boolean isCompleted() { return completed; } public void setCompleted(boolean completed) { this.completed = completed; } @Override public String toString() { return String.format("id: %s, userId: %s, title: %s, completed: %s", id, userId, title, completed); } } 

服务类

TodoService.java：

import java.util.List; import feign.Param; import feign.RequestLine; public interface TodoService { @RequestLine("GET") List<Todo> findAll(); @RequestLine("GET /{id}") Todo findOne(@Param("id") int id); } 

主程序

public class App { public static void main(String[] args) { org.slf4j.Logger log = LoggerFactory.getLogger(App.class); TodoService client = Feign.builder() .client(new OkHttpClient()) .encoder(new GsonEncoder()) .decoder(new GsonDecoder()) .logger(new Slf4jLogger(App.class)) .logLevel(Logger.Level.FULL) .target(TodoService.class, "https://jsonplaceholder.typicode.com/todos"); List<Todo> all = client.findAll(); if(all != null) { log.info("Size: " + all.size()); } Todo todo = (Todo) client.findOne(1); log.info(String.valueOf(todo)); } } 

运行结果

输出：

[main] INFO demo.App - Size: 200 [main] INFO demo.App - id: 1, userId: 1, title: delectus aut autem, completed: false 

由于样例中日志设置了DEBUG级别，在输出内容中可以看到详细的请求过程和返回结果。

三、Spring Boot样例

数据源

同上面样例中的数据源

模型类

同上面样例中的模型类

依赖

pom.xml：

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.7.18</version> <relativePath/> <!-- lookup parent from repository --> </parent> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>2021.0.9</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> </dependencies> 

服务类

import java.util.List; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; @FeignClient(name = "todo-service", url = "https://jsonplaceholder.typicode.com") public interface TodoService { @RequestMapping(value = "/todos", method = RequestMethod.GET) List<Todo> findAll(); @RequestMapping(value = "/todos/{id}", method = RequestMethod.GET) Todo findOne(@PathVariable("id") int id); } 

控制器类

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; @RestController public class TodoController { @Autowired private TodoService todoService; @GetMapping("/getTodos") public ResponseEntity<?> getTodos(){ return ResponseEntity.ok(todoService.findAll()); } @GetMapping("/getTodo/{id}") public ResponseEntity<?> getTodo(@PathVariable int id){ return ResponseEntity.ok(todoService.findOne(id)); } } 

主程序

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.openfeign.EnableFeignClients; @SpringBootApplication @EnableFeignClients public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } } 

运行

访问http://localhost:8080/getTodos可以获取所有待办事项；

访问http://localhost:8080/getTodo/1可以获取id为1的待办事项。

参考资料

TiddlyWiki简介

2025-09-20T00:00:00+08:00

一、简介

TiddlyWiki是一款个人知识管理工具，它拥有独特的单文件架构以及灵活的知识组织方式。可以用来构建个人知识体系、打造学习笔记系统或者创建待办事项、设定截止日期、跟踪项目进度等。

二、下载安装

安装

运行以下命令安装TiddlyWiki：

npm install -g tiddlywiki

安装完成后可以使用tiddlywiki --version查看版本：

tiddlywiki --version

输出：

5.3.8

初始化

创建wiki服务目录：

tiddlywiki mywiki --init server

输出：

Copied edition 'server' to mywiki

启动

启动wiki服务：

tiddlywiki mywiki --listen

输出：

syncer-server-filesystem: Dispatching 'save' task: $:/StoryList Serving on http://127.0.0.1:8080 

或者指定端口：

tiddlywiki mywiki --listen port=8888

三、使用

访问http://localhost:8080/可以看到wiki首页：

可以新增记录：

或者配置wiki：

文章内容存储在服务目录的tiddlers目录下：

参考资料

A Gentle Guide to TiddlyWiki

Gif图像转为视频

2025-08-31T00:00:00+08:00

一、场景

需要将PPT中的gif图像转换为视频以便控制播放。

如果需要处理单个gif图像，可以使用以下命令：

ffmpeg -i input.gif -pix_fmt yuv420p output.wmv

其中-pix_fmt yuv420p指定了输出视频的像素格式为：yuv420p；yuv420p是最常用的8-bit 4:2:0采样格式，兼容性最好。

二、实现

1、提取GIF图像

将PPT复制一份并将后缀改为xxx.zip
在解压后的ppt\media目录中找出所有的gif文件

2、编写批处理脚本

@echo off setlocal enabledelayedexpansion set INPUT_DIR=./input set OUTPUT_DIR=./out if "%INPUT_DIR%"=="" set INPUT_DIR=. if "%OUTPUT_DIR%"=="" set OUTPUT_DIR=%INPUT_DIR% for %%i in ("%INPUT_DIR%\*.gif") do ( ffmpeg -i "%%i" -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" -pix_fmt yuv420p -b:v 5000k -maxrate 5000k -bufsize 1000k -c:v wmv2 "%OUTPUT_DIR%\%%~ni.wmv" echo 转换完成: %%i → %OUTPUT_DIR%\%%~ni.wmv ) 

运行此脚本，即可将input目录下的gif文件全部转换为wmv视频文件。

三、问题及解决办法

1、在PPT中插入视频时提示无法插入

处理方式：

将输出文件改为wmv格式，命令由：

ffmpeg -i input.gif -pix_fmt yuv420p output.mp4

改为

ffmpeg -i input.gif -pix_fmt yuv420p output.wmv

2、部分转换时提示缓冲区下溢

部分gif文件转换时提示：

[wmv2 @ 00000000005288c0] rc buffer underflow [wmv2 @ 00000000005288c0] max bitrate possibly too small or try trellis with large lmax or increase qmax 

处理方式：

调整命令中的参数，命令由：

ffmpeg -i "%%i" -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" -pix_fmt yuv420p -b:v 5000k -maxrate 5000k -bufsize 1000k -c:v wmv2 "%OUTPUT_DIR%\%%~ni.wmv" 

调整为（调整目标码率-b:v、最大码率maxrate和缓冲区bufsize大小）：

ffmpeg -i "%%i" -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" -pix_fmt yuv420p -b:v 8000k -maxrate 12000k -bufsize 16000k -c:v wmv2 "%OUTPUT_DIR%\%%~ni.wmv" 

Nacos简介

2025-07-27T00:00:00+08:00

一、简介

1、概述

Nacos(Dynamic Naming and Configuration Service)是一个开源的动态服务发现、配置管理和服务管理平台。

2、下载

下载nacos-server-xxx.zip后解压。

3、运行

切换到bin目录，执行以下命令（standalone代表着单机模式运行，非集群模式）：

startup.cmd -m standalone

访问http://localhost:8848/nacos即可打开Nacos管理控制台：

二、核心功能

1、命名空间

Nacos的命名空间（Namespace）可以实现多环境（如开发、测试、生产）或多租户的隔离，可以为不同的环境创建不同的命名空间，实现配置和服务的完全隔离。

Nacos通过Namespace、Group、Data ID等元素来唯一确定一个配置或服务，不同的命名空间下，可以存在相同的Group 或 Data ID的配置。

2、服务发现与注册

服务提供者（Provider）在启动时，会向Nacos服务器注册自己的服务信息（例如IP、端口、服务名等）；服务消费者（Consumer）通过Nacos查询并获取可用的服务实例列表，从而实现服务间的发现与调用。

服务注册

curl -X POST "http://127.0.0.1:8848/nacos/v1/ns/instance?serviceName=nacos.naming.serviceName&ip=20.18.7.10&port=8080" 

服务发现

curl -X GET "http://127.0.0.1:8848/nacos/v1/ns/instance/list?serviceName=nacos.naming.serviceName" 

Java样例

package demo; import java.util.Properties; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.alibaba.nacos.api.NacosFactory; import com.alibaba.nacos.api.PropertyKeyConst; import com.alibaba.nacos.api.naming.NamingService; import com.alibaba.nacos.api.naming.listener.Event; import com.alibaba.nacos.api.naming.listener.EventListener; import com.alibaba.nacos.api.naming.listener.NamingEvent; public class NacosNamingExample { public static void main(String[] args) throws Exception{ Logger log = LoggerFactory.getLogger(NacosNamingExample.class); Properties properties = new Properties(); //Nacos地址 properties.put(PropertyKeyConst.SERVER_ADDR, "localhost:8848"); //指定命名空间 properties.put(PropertyKeyConst.NAMESPACE, "dev"); NamingService namingService = NacosFactory.createNamingService(properties); //注册服务 namingService.registerInstance("testService", "10.0.0.1", 8080); wait2Sync(); //订阅服务 namingService.subscribe("testService", new EventListener() { @Override public void onEvent(Event event) { if(event instanceof NamingEvent) { NamingEvent namingEvent = (NamingEvent) event; log.info("serviceName: {}", namingEvent.getServiceName()); log.info("instances: {}", namingEvent.getInstances()); } } }); namingService.registerInstance("testService", "10.0.0.2", 8080);; wait2Sync(); } /** * 等待同步nacos */ private static void wait2Sync() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } 

输出：

serviceName: testService instances: [Instance{instanceId='10.0.0.1#8080#DEFAULT#DEFAULT_GROUP@@testService', ip='10.0.0.1', port=8080, weight=1.0, healthy=true, enabled=true, ephemeral=true, clusterName='DEFAULT', serviceName='DEFAULT_GROUP@@testService', metadata={}}] serviceName: testService instances: [Instance{instanceId='10.0.0.2#8080#DEFAULT#DEFAULT_GROUP@@testService', ip='10.0.0.2', port=8080, weight=1.0, healthy=true, enabled=true, ephemeral=true, clusterName='DEFAULT', serviceName='DEFAULT_GROUP@@testService', metadata={}}] 

3、动态配置管理

Nacos提供了一个中心化的配置服务器，可以通过Nacos控制台统一管理所有环境的配置信息。当配置需要变更时，无需重启应用，Nacos就能将变更的配置实时推送到客户端并生效，极大减少了系统停机时间，为实现灰度发布、版本控制等高级特性提供了基础。

发布配置

curl -X POST "http://127.0.0.1:8848/nacos/v1/cs/configs?dataId=nacos.cfg.dataId&group=test&content=HelloWorld" 

获取配置

curl -X GET "http://127.0.0.1:8848/nacos/v1/cs/configs?dataId=nacos.cfg.dataId&group=test" 

Java样例

package demo; import java.util.Properties; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.alibaba.nacos.api.NacosFactory; import com.alibaba.nacos.api.PropertyKeyConst; import com.alibaba.nacos.api.config.ConfigService; import com.alibaba.nacos.api.config.listener.AbstractListener; import com.alibaba.nacos.client.config.listener.impl.PropertiesListener; public class NacosConfigExample { public static void main(String[] args) throws Exception{ Logger log = LoggerFactory.getLogger(NacosConfigExample.class); Properties properties = new Properties(); //Nacos地址 properties.put(PropertyKeyConst.SERVER_ADDR, "127.0.0.1:8848"); ConfigService configService = NacosFactory.createConfigService(properties); String group = "testGroup"; String dataId = "testDataId"; String content = "connectTimeoutInMills=5000"; //监听配置 configService.addListener(dataId, group, new PropertiesListener() { @Override public void innerReceive(Properties properties) { //Properties类型 log.info("receive: {}", properties); } }); configService.addListener(dataId, group, new AbstractListener() { @Override public void receiveConfigInfo(String configInfo) { //其他类型配置，例如json、yaml或pojo对象，可按需做反序列化 log.info("receive(String): {}", configInfo); } }); //发布配置 boolean result = configService.publishConfig(dataId, group, content); log.info("publishConfig: {}", result); wait2Sync(); //查询配置 String config = configService.getConfig(dataId, group, 3000); log.info("getConfig: {}", config); //更新配置 String newContent = "connectTimeoutInMills=3000"; boolean updateResult = configService.publishConfig(dataId, group, newContent); log.info("updateConfig: {}", updateResult); wait2Sync(); //删除配置 boolean removeResult = configService.removeConfig(dataId, group); log.info("removeConfig: {}", removeResult); wait2Sync(); config = configService.getConfig(dataId, group, 3000); log.info("getConfig: {}", config); } /** * 等待同步nacos */ private static void wait2Sync() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } 

输出：

publishConfig: true receive: {connectTimeoutInMills=5000} receive(String): connectTimeoutInMills=5000 getConfig: connectTimeoutInMills=5000 updateConfig: true receive: {connectTimeoutInMills=3000} receive(String): connectTimeoutInMills=3000 removeConfig: true receive(String): null getConfig: null 

三、部署模式

1、单机

启动

执行以下命令：

startup.cmd -m standalone

或修改startup.cmd中的MODE变量后直接运行startup.cmd：

set MODE="standalone"

使用MySQL

单机模式时默认使用内置数据库Derby实现数据的存储，可以通过配置使用MySQL(5.6.5+)作为数据存储，步骤如下：
- 初始化nacos数据库
执行conf\mysql-schema.sql文件完成初始化。
- 配置数据源
修改conf\application.properties文件，增加数据库配置：
```
 spring.sql.init.platform=mysql db.num=1 db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC db.user.0=nacos db.password.0=nacos 
```

2、集群

集群模式通常用于生产环境，确保高可用；需要3个或3个以上Nacos节点才能构成集群。

步骤如下：

配置集群

在conf\cluster.conf中配置节点信息：

200.8.9.16:8848 200.8.9.17:8848 200.8.9.18:8848

开启默认鉴权插件（可选）

Nacos是一个内部微服务组件，需要在可信的内部网络中运行，不可暴露在公网环境，防止带来安全风险。

Nacos提供简单的鉴权实现，为防止业务错用的弱鉴权体系，不是防止恶意攻击的强鉴权体系。

如果运行在不可信的网络环境或者有强鉴权诉求，可以参考鉴权插件实现自定义鉴权。

可以通过如下步骤开启默认鉴权：

修改conf\application.properties文件，增加鉴权配置：

nacos.core.auth.enabled=true nacos.core.auth.system.type=nacos #base64字符串 nacos.core.auth.plugin.nacos.token.secret.key=${自定义，保证所有节点一致} nacos.core.auth.server.identity.key=${自定义，保证所有节点一致} nacos.core.auth.server.identity.value=${自定义，保证所有节点一致} 

配置MySQL数据源

执行conf\mysql-schema.sql文件完成初始化
修改conf\application.properties配置文件

 spring.sql.init.platform=mysql db.num=1 db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC db.user.0=nacos db.password.0=nacos 

启动三个节点后，访问http://localhost:8848/nacos/，需要登录：

输入nacos/nacos即可登录成功。

登录后在节点列表中可以看到Nacos节点信息（此处使用同一机器不同端口启动多个Nacos服务）：

四、其他

配置鉴权插件后客户端连接时需传递认证信息

properties.setProperty(PropertyKeyConst.USERNAME, "nacos"); properties.setProperty(PropertyKeyConst.PASSWORD, "nacos"); 

自定义用户信息

使用BCrypt加密密码：

//创建BCrypt加密器实例 BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(); //明文密码 String rawPassword = "hello"; //加密密码 String encodedPassword = encoder.encode(rawPassword); System.out.println("BCrypt加密后的密码: " + encodedPassword); 

然后在users和roles表中插入相关信息：

INSERT INTO users (username, password, enabled) VALUES ('xxx', '$2a$10$gUteC5T1metlzuBytrAdyeudXmZ4N025MwIt77Z.sgm7bj6311962', TRUE); INSERT INTO roles (username, role) VALUES ('xxx', 'ROLE_ADMIN'); 

之后就可以使用此用户密码登录。

参考资料

Hystrix简介

2025-06-15T00:00:00+08:00

一、简介

1、概述

Hystrix是Netflix开源的一个用于处理分布式系统延迟和容错的库，主要目标是防止在复杂的分布式系统中出现级联故障，从而提高系统的弹性。

2、核心概念

Circuit breaker

断路器是软件开发中使用的一种设计模式，它在监控故障达到特定阈值时开启，从而防止对故障服务的进一步调用，提高系统弹性。

Hystrix是实现了断路器模式的库，它提供了使用HTTP或其他协议调用远程服务时处理故障的机制：当达到指定的错误阈值时，断路器会打开，并在指定时间段后再次关闭，允许继续尝试调用；它还提供了回退机制来优雅地处理故障。

Command

有断路器功能的服务调用。

Fallback

一种备份机制，在命令失败或断路器打开时提供默认行为，防止应用程序因故障而崩溃。

Timeout

如果命令超过此时间，则中止该命令，并调用回退机制（Fallback）。

Rolling Window

Hystrix监控服务运行状况的时间窗口，通过计算此窗口内的错误百分比和请求量等指标来决定断路器是否开启。

Isolation

Hystrix使用单独的线程、线程池或信号量来提供命令的隔离，确保一个命令中的故障不会影响其他命令，从而提供容错能力。

Metrics

Hystrix收集的数据指标，例如成功率、失败率、延迟和并发等；这些指标用于决定是否开启断路器以及用于监视和调试。

Thread Pool

Hystrix用于异步执行命令的线程池，每个命令都可以有对应的线程池，从而防止命令之间的资源竞争。

二、样例

1、纯Hystrix

依赖

<dependencies> <dependency> <groupId>com.netflix.hystrix</groupId> <artifactId>hystrix-core</artifactId> <version>1.5.18</version> </dependency> </dependencies> 

Command

服务调用类：

import com.netflix.hystrix.HystrixCommand; public class RemoteCallCommand extends HystrixCommand<String>{ private String input; private long time; public RemoteCallCommand(Setter setter, String input) { super(setter); this.input = input; } @Override protected String run() throws Exception { //模拟服务不稳定，随机Sleep 0~1000ms time = (long) (Math.random() * 1000); Thread.sleep(time); return String.format("[SUCCESS] input: %s, time: %s", input, time); } @Override protected String getFallback() { return String.format("[Fallback] input: %s, time: %s", input, time); } } 

主程序

import com.netflix.hystrix.HystrixCommand.Setter; import com.netflix.hystrix.HystrixCommandGroupKey; import com.netflix.hystrix.HystrixCommandProperties; import com.netflix.hystrix.HystrixThreadPoolProperties; public class App { public static void main(String[] args) throws Exception{ Setter setter = getHystrixCommandSetter(); RemoteCallCommand command = null; for(int i = 1; i <= 20; i++) { String input = String.format("command-%s", i); command = new RemoteCallCommand(setter, input); String ret = command.execute(); System.out.println(String.format("%s:%s", i, ret)); } } private static Setter getHystrixCommandSetter() { Setter setter = Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("demoGroup")); //线程池配置 HystrixThreadPoolProperties.Setter threadPollProps = HystrixThreadPoolProperties.Setter(); threadPollProps.withCoreSize(5); threadPollProps.withMaxQueueSize(10); setter.andThreadPoolPropertiesDefaults(threadPollProps); //熔断器、超时配置 HystrixCommandProperties.Setter commandProps = HystrixCommandProperties.Setter(); commandProps.withCircuitBreakerEnabled(true); commandProps.withCircuitBreakerRequestVolumeThreshold(5); commandProps.withCircuitBreakerErrorThresholdPercentage(50); commandProps.withCircuitBreakerSleepWindowInMilliseconds(3000); commandProps.withExecutionTimeoutInMilliseconds(800); setter.andCommandPropertiesDefaults(commandProps); return setter; } } 

HystrixCommand配置
- withCircuitBreakerEnabled(true)
是否启用熔断器，默认值为true。
- withMetricsRollingStatisticalWindowInMilliseconds(int)
熔断器做失败率统计时的滑动窗口长度，默认为10000ms（10s）。
- withCircuitBreakerRequestVolumeThreshold(5)
滑动窗口内触发熔断的最小请求数，默认值为20。

上面的设置表示如果10秒内的总请求数 <5，即使全失败也不会打开熔断器，防止少量调用毛刺导致误判。
- withCircuitBreakerErrorThresholdPercentage(50)
达到上面的最小请求数后，如果失败率 >=50% 即开启断路。
- withCircuitBreakerSleepWindowInMilliseconds(3000)
熔断器断路后的休眠时间，即这段时间内的所有请求直接走fallback，休眠结束后进入半开状态，允许一条探测请求通过；默认5000ms（5s）。
- withExecutionTimeoutInMilliseconds(800)
单条命令的执行超时，超时后run()方法会被中断（线程池模式）并进入getFallback()方法；设为0代表永不超时，默认1000ms（1s）。
运行

输出：

1:[Fallback] input: command-1, time: 847 2:[SUCCESS] input: command-2, time: 717 3:[SUCCESS] input: command-3, time: 264 4:[SUCCESS] input: command-4, time: 590 5:[SUCCESS] input: command-5, time: 183 6:[Fallback] input: command-6, time: 919 7:[Fallback] input: command-7, time: 821 8:[Fallback] input: command-8, time: 897 9:[SUCCESS] input: command-9, time: 339 10:[SUCCESS] input: command-10, time: 603 11:[SUCCESS] input: command-11, time: 5 12:[SUCCESS] input: command-12, time: 81 13:[SUCCESS] input: command-13, time: 96 14:[SUCCESS] input: command-14, time: 705 15:[SUCCESS] input: command-15, time: 474 16:[SUCCESS] input: command-16, time: 172 17:[Fallback] input: command-17, time: 902 18:[Fallback] input: command-18, time: 871 19:[SUCCESS] input: command-19, time: 533 20:[SUCCESS] input: command-20, time: 642 

2、使用SpringBoot

依赖

pom.xml：

<properties> <spring-cloud.version>Hoxton.SR12</spring-cloud.version> </properties> <dependencyManagement> <dependencies> <!-- 引入 Spring Cloud Hoxton 的依赖管理 --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <!-- Spring Boot Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.2.6.RELEASE</version> </dependency> <!-- 使用 Netflix Hystrix Starter --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-hystrix</artifactId> <!-- 版本由 dependencyManagement 控制，无需在此指定 --> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.15.0</version> <!-- 建议使用与Spring Boot兼容的版本 --> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.15.0</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-annotations</artifactId> <version>2.15.0</version> </dependency> </dependencies> 

服务

public interface RemoteService { String callService(); } 

服务实现类

import java.util.Random; import org.springframework.stereotype.Service; import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand; @Service public class RemoteServiceImpl implements RemoteService{ @Override @HystrixCommand(fallbackMethod = "reliable") public String callService() { if(new Random().nextBoolean()) { throw new RuntimeException("Service Failure!"); } return "Successfully called service!"; } public String reliable() { return "Default Response."; } } 

常用的配置项如下：

@HystrixCommand( fallbackMethod = "fallback", commandKey = "xxxCmd", groupKey = "xxxGroup", threadPoolKey = "xxxPool", /* 命令属性 */ commandProperties = { @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds", value="1500"), @HystrixProperty(name="circuitBreaker.requestVolumeThreshold", value="10"), @HystrixProperty(name="circuitBreaker.errorThresholdPercentage", value="60"), @HystrixProperty(name="circuitBreaker.sleepWindowInMilliseconds", value="5000") }, /* 线程池属性 */ threadPoolProperties = { @HystrixProperty(name="coreSize", value="10"), @HystrixProperty(name="maxQueueSize", value="50") } ) 

控制器类

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class ServiceController { @Autowired private RemoteService remoteService; @GetMapping("/service") public String call() { try { return remoteService.callService(); } catch (Exception e) { e.printStackTrace(); return "Failed to call service"; } } } 

主程序

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker; @SpringBootApplication @EnableCircuitBreaker public class CircuitBreakerHystrixApp { public static void main(String[] args) { SpringApplication.run(CircuitBreakerHystrixApp.class, args); } } 

运行

多次访问[http://localhost:8080/service]{http://localhost:8080/service}，可以看到：

请求成功时显示：

Successfully called service!

请求失败时返回Service中reliable方法的内容：

Default Response.