mysql

使用 mysql2 包

mysql2 版本： ^2.2.5

首先 npm 安装

npm install --save mysql2

定义一个包含 mysql 信息的 config 对象：

// mysql 连接配置
const mysqlConfig = {
  host: 'localhost',
  port: '3306',
  user: 'root',
  password: 'cg9837',
  database: 'jschen_server_test',
}

定义一个测试连接的函数, 使用 promise 的方式来连接（也支持 callback，详情看此处）

const mysql = require('mysql2/promise')
async function testConnection() {
  const connection = await mysql.createConnection(mysqlConfig)
  const [rows] = await connection.execute('select now();')
  return rows
}

// 直接利用 node 测试
;(async () => {
  const rows = await testConnection()
  console.log(rows) // [ { 'now()': 2024-12-28T08:02:10.000Z } ]
})()

此时可以把 connection 导出出去即可。

使用 sequelize 连接 mysql

sequelize 版本：^6.3.5

npm 安装：

npm install --save sequelize

依旧使用上面的 mysqlConfig

const { Sequelize } = require('sequelize')
const { isPrd, isTest } = require('../../utils/env')

const { user, password, host, port, database } = mysqlConfig
const conf = {
  host,
  port,
  dialect: 'mysql',
}

//  test 环境不打印日志
if (isTest) {
  conf.logging = () => {}
}

if (isPrd) {
  conf.pool = {
    max: 5,
    min: 0,
    idle: 10000,
  }
}

const seq = new Sequelize(database, user, password, conf)

module.exports = seq

下面是 env 文件：

const ENV = process.env.NODE_ENV || ''

module.exports = {
  ENV,
  isPrd: ENV === 'production',
  idPrdDev: ENV === 'prd_dev',
  isDev: ENV == 'dev',
  isTest: ENV.indexOf('test') === 0,
  isTestLocal: ENV === 'test_local',
  isTestRemote: ENV === 'test_remote',
}

然后测试是否连接成功：

seq
  .authenticate()
  .then(() => {
    console.log('ok')
  })
  .catch(() => {
    console.log('fail')
  })
  .finally(() => {
    process.exit()
  })

其他用法请参考链接

redis

redis 版本：^3.0.2

首先创建一个 config 对象：

const redisConf = {
  port: '6379',
  host: '127.0.0.1',
}

连接数据库, 获取redis实例：

const redis = require('redis')

const { redisConf } = require('../config/index')

const { port, host, password } = redisConf
const opt = {}

if (password) {
  opt.password = password
}

const redisClient = redis.createClient(port, host, opt)
redisClient.on('error', (err) => {
  console.error('connection error', err)
})

// redisClient.on('connect', () => {
//   console.log('success')
//   redisClient.set('foo', 'bar', redis.print)
//   redisClient.get('foo', redis.print)
//   redisClient.quit()
// })

module.exports = redisClient

封装常用的 get， set 方法：

const redisClient = require('../db/redis')

function cacheSet(key, val, timeout = 60 * 60) {
  let formatVal
  if (typeof val === 'object') {
    formatVal = JSON.stringify(obj)
  } else {
    formatVal = val
  }
  redisClient.set(key, formatVal)
  redisClient.expire(key, timeout)
}

function cacheGet(key) {
  const promise = new Promise((resolve, reject) => {
    redisClient.get(key, (err, val) => {
      if (err) {
        reject(err)
        return
      }
      if (val == null) {
        resolve(null)
        return
      }
      try {
        resolve(JSON.parse(val))
      } catch (ex) {
        resolve(val)
      }
    })
  })
  return promise
}

module.exports = {
  cacheGet,
  cacheSet,
}

最后进行测试：

cacheSet('name', 'thats OK')
const testRedisVal = await cacheGet('name')
console.log(testRedisVal) // thats OK

mongoDB

mongoose 版本：^5.11.3

首先定义对象config ：

const mongodbConf = {
  host: '127.0.0.1',
  port: '27017',
  dbName: 'jschen_server_test',
}

然后连接 mongoDB：

const mongoose = require('mongoose')
const { mongodbConf } = require('../config/index')

const { port, host, dbName, user, password } = mongodbConf

// 拼接字符串
let url = `mongodb://${host}:${port}`
if (user && password) {
  url = `mongodb://${user}:${password}@${host}:${port}`
}

mongoose.set('useCreateIndex', true)
mongoose.set('useFindAndModify', false)

mongoose.connect(`${url}/${dbName}?authSource=admin`, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
})

const db = mongoose.connection

db.on('error', (err) => {
  console.error('mongoose connect error', err)
})

// 测试
// db.once('open', () => {
//   console.log('success')
// })

module.exports = mongoose

然后定义一个 model：

const mongoose = require('../db/mongoose')

const WorkSchema = mongoose.Schema(
  {
    title: String,
    components: [Object],
    props: Object,
    setting: Object,
  },
  {
    timestamps: true,
  }
)

const WorkModel = mongoose.model('work', WorkSchema)

module.exports = {
  WorkModel,
}

获取数据：

await WorkModel.findOne()