Node.Js Express Sqlite3 接口开发

书中自有妍如玉2025-11-04 20:07

要使用Express，首先需要安装Node.js环境，然后通过npm init -y创建package.json文件，再输入npm install express安装框架。在实际使用中，Express 4或5版本均可使用。

新建app.js 文件 创建一个localhost:3012的应用程序

复制代码 
const express = require('express');
const app = express();
const PORT = process.env.PORT || 3012;




// 应用基础中间件
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 静态文件服务中间件
app.use(express.static('public'));


app.all('/api/contrlor/action',async(req,res)=>{
  try{
    var SQLiteDB  =require("./DB/node_sqlite3_orm");
    const db = new SQLiteDB(path.join(__dirname,"./database/test.db"));
    var id=req.body.id;
	var data=await db.find("DeviceOnline",{Id:id});
	var model=Enumerable.from(data).where(p=>p.Id == id).firstOrDefault(null);//单个信息
    res.send({code:200,rc:true,model});
  }
  catch(error){
    console.log(error);
    res.send({ code:500,rc: false,str: error.message});
  }
  finally{
      
  }

});


app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

其中app.all 是api接口 也可以用路由中间件实现

复制代码 
var router = express.Router();

router .all('/contrlor/action',async(req,res)=>{
  try{
    var id=req.body.id;
	var data=await db.find("DeviceOnline",{Id:id});
	var model=Enumerable.from(data).where(p=>p.Id == id).firstOrDefault(null);//单个信息
    res.send({code:200,rc:true,model});
  }
  catch(error){
    console.log(error);
    res.send({ code:500,rc: false,str: error.message});
  }
  finally{
      
  }

});

app.use('/api',router);

db是数据ORM操作对象

复制代码 
const sqlite3 = require('sqlite3').verbose();
// const { EventEmitter } = require('events');

class SQLiteORM {
  constructor(dbPath = ':memory:') {
	  this.dbPath=dbPath;
    this.db = new sqlite3.Database(dbPath);
    this.models = new Map();
    this.lock = {
      readers: 0,
      writer: false,
      readQueue: [],
      writeQueue: []
    };
  }

  // 读写锁实现
  async _acquireRead() {
    return new Promise(resolve => {
      if (!this.lock.writer && this.lock.writeQueue.length === 0) {
        this.lock.readers++;
        resolve();
      } else {
        this.lock.readQueue.push(resolve);
      }
    });
  }

  async _acquireWrite() {
    return new Promise(resolve => {
      if (this.lock.readers === 0 && !this.lock.writer) {
        this.lock.writer = true;
        resolve();
      } else {
        this.lock.writeQueue.push(resolve);
      }
    });
  }

   _releaseRead() {
    this.lock.readers--;
    if (this.lock.readers === 0 && this.lock.writeQueue.length > 0) {
      this.lock.writer = true;
      const next = this.lock.writeQueue.shift();
      next();
    }
  }

  _releaseWrite() {
    this.lock.writer = false;
    while (this.lock.readQueue.length > 0) {
      this.lock.readers++;
      const next = this.lock.readQueue.shift();
      next();
    }
  }



  // ORM核心方法
  defineModel(name, schema) {
    const model = {
      name,
      schema,
      fields: Object.keys(schema),
      createTable: async () => {
        const columns = Object.entries(schema)
          .map(([field, type]) => `${field} ${type}`)
          .join(',');
        await this.run(`CREATE TABLE IF NOT EXISTS ${name} (${columns})`);
      }
    };
    this.models.set(name, model);
    return model;
  }

  // CRUD操作
  // 基础SQL执行方法
  async execute(sql, where = {}) {
	  this.open();
    const conditions = Object.keys(where).map(k => `${k} = ?`).join(' AND ');
    const values = Object.values(where);
    await this._acquireRead();
    try {
      return new Promise((resolve, reject) => {
        this.db.all(
          `${sql} ${conditions ? 'WHERE ' + conditions : ''}`,
          values,
          (err, rows) => {
            this._releaseRead();
            err ? reject(err) : resolve(rows);
          }
        );
      });
    } catch (err) {
      this._releaseRead();
      throw err;
    }finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }
  async executeSql(sql) {
	  this.open();
    await this._acquireRead();
    try {
      return new Promise((resolve, reject) => {
        this.db.all(
          `${sql} ${conditions ? 'WHERE ' + conditions : ''}`,
          [],
          (err, rows) => {
            this._releaseRead();
            err ? reject(err) : resolve(rows);
          }
        );
      });
    } catch (err) {
      this._releaseRead();
      throw err;
    }finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }
  
  async insert(modelName, data) {
	  this.open();
    var self=this;
    const model = this.models.get(modelName);
    const fields = Object.keys(data).join(',');
    const placeholders = Object.keys(data).map(() => '?').join(',');
    await this._acquireWrite();
    try {
      return new Promise((resolve, reject) => {
        this.db.run(
          `INSERT INTO ${modelName} (${fields}) VALUES (${placeholders})`,
          Object.values(data),
          function(err) {
            self._releaseWrite();
            err ? reject(err) : resolve(this.lastID);
          }
        );
      });
    } catch (err) {
      this._releaseWrite();
      throw err;
    }finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }

  async insertBatch(modelName, arr) {
	  this.open();
    var self=this;
    await this._acquireWrite();
    try{
      return new Promise((resolve, reject) => {
        for(var data of arr){
          const model = this.models.get(modelName);
          var fields = Object.keys(data).join(',');
          var placeholders = Object.keys(data).map(() => '?').join(',');
          this.db.run(
              `INSERT INTO ${modelName} (${fields}) VALUES (${placeholders})`,
              Object.values(data),
              function(err) {
                self._releaseWrite();
                err ? reject(err) : resolve(this.lastID);
              }
            );
        }
      });
    }
    catch (err) {
      this._releaseWrite();
      throw err;
    }finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }

  async find(modelName, where = {}, options = {}) {
	  this.open();
    const model = this.models.get(modelName);
    const conditions = Object.keys(where).map(k => `${k} = ?`).join(' AND ');
    const values = Object.values(where);
    await this._acquireRead();
    try {
      return new Promise((resolve, reject) => {
        this.db.all(
          `SELECT * FROM ${modelName} ${conditions ? 'WHERE ' + conditions : ''}`,
          values,
          (err, rows) => {
            this._releaseRead();
            err ? reject(err) : resolve(rows);
          }
        );
      });
    } catch (err) {
      this._releaseRead();
      throw err;
    }finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }

  async update(modelName, where, data) {
	  this.open();
    var self=this;
    const setClause = Object.keys(data).map(k => `${k} = ?`).join(',');
    const whereClause = Object.keys(where).map(k => `${k} = ?`).join(' AND ');
    const values = [...Object.values(data), ...Object.values(where)];
    await this._acquireWrite();
    try {
      return new Promise((resolve, reject) => {
		
        this.db.run(
          `UPDATE ${modelName} SET ${setClause} ${whereClause ? 'WHERE ' + whereClause : ''}`,
          values,
          function(err) {
            self._releaseWrite();
            err ? reject(err) : resolve(this.changes);
          }
        );
      });
    } catch (err) {
      this._releaseWrite();
      throw err;
    } finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }

  async updateBatch(modelName,where, arr) {
	  this.open();
    await this._acquireWrite();
    try{
      var self=this;
      return new Promise((resolve, reject) => {
        for(var data of arr){
          const setClause = Object.keys(data).map(k => `${k} = ?`).join(',');
          const whereClause = Object.keys(where).map(k => `${k} = ?`).join(' AND ');
          const values = [...Object.values(data), ...Object.values(where)];
          this.db.run(
              `UPDATE ${modelName} SET ${setClause} ${whereClause ? 'WHERE ' + whereClause : ''}`,
              values,
              function(err) {
                self._releaseWrite();
                err ? reject(err) : resolve(this.lastID);
              }
            );
        }
      });
    }
    catch (err) {
      this._releaseWrite();
      throw err;
    }finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }

  async delete(modelName, where) {
	  this.open();
    const whereClause = Object.keys(where).map(k => `${k} = ?`).join(' AND ');
    const values = Object.values(where);
    await this._acquireWrite();
    var self=this;
    try {
      return new Promise((resolve, reject) => {
        this.db.run(
          `DELETE FROM ${modelName} ${whereClause ? 'WHERE ' + whereClause : ''}`,
          values,
          function(err) {
            self._releaseWrite();
            err ? reject(err) : resolve(this.changes);
          }
        );
      });
    } catch (err) {
      this._releaseWrite();
      throw err;
    } finally {
	  this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }

  async transaction(callback) {
	  this.open();
    await this._acquireWrite();
    try {
      await this.run('BEGIN TRANSACTION');
      const result = await callback();
      await this.run('COMMIT');
      return result;
    } catch (err) {
      await this.run('ROLLBACK');
      throw err;
    } finally {
      this._releaseWrite();
	    this.close().then((data)=>{console.log('数据库连接已关闭');}).catch((ex)=>{console.log(ex);});
    }
  }
	
  open(dbPath = ':memory:') {
    try{
	   this.db = new sqlite3.Database(this.dbPath?this.dbPath:dbPath);
     console.log('数据库连接已打开');
	  }
	  catch(error){
      console.log(error);
	  }
	  finally{
		  
	  }
  }
  
  close() {
    return new Promise((resolve, reject) => {
      this.db.close(err => {
        err ? reject(err) : resolve();
      });
    });
  }
}

module.exports = SQLiteORM;

// 使用示例：
// const SQLiteORM = require('./sqlite-orm');
// const db = new SQLiteORM('test.db');

// // 定义模型
// db.defineModel('users', {
//   id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
//   name: 'TEXT NOT NULL',
//   age: 'INTEGER'
// });

// // 创建表
// await db.models.get('users').createTable();

// // CRUD操作
// const userId = await db.create('users', { name: 'Alice', age: 25 });
// const users = await db.find('users', { age: 25 });
// const updated = await db.update('users', { id: userId }, { age: 26 });
// const deleted = await db.delete('users', { id: userId });

接口服务

使用apipost接口调试工具

相关推荐
冴羽21 小时前
涨见识了，Error.cause 让 JavaScript 错误调试更轻松
前端·javascript·node.js
m***D28621 小时前
JavaScript在Node.js中的内存管理
开发语言·javascript·node.js
Hello eveybody21 小时前
Node.js环境变量配置实战
node.js
q***615021 小时前
Windows 上彻底卸载 Node.js
windows·node.js
q***4641 天前
使用Node.js搭配express框架快速构建后端业务接口模块Demo
node.js·express
青靴1 天前
轻量级 CI/CD：Git Hooks 自动部署 Node.js 应用（CICD-demo）
git·ci/cd·node.js
孟祥_成都1 天前
别被营销号误导了！你以为真的 Bun 和 Deno 比 Node.js 快很多吗？
前端·node.js
labixiong1 天前
理解pnpm的本质，如何通过高效管理提升项目效率
前端·javascript·node.js
良木林2 天前
Node.js基础：模块化与包
开发语言·前端·node.js
q***49862 天前
Node.js卸载超详细步骤(附图文讲解)
node.js
热门推荐
01GitHub 镜像站点02【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连03BongoCat - 跨平台键盘猫动画工具04UV安装并设置国内源05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南07Linux下V2Ray安装配置指南08全球最强模型Grok4，国内已可免费使用！（附教程）09Labelme从安装到标注：零基础完整指南10Spring Boot 4.0 发布总结：新特性、依赖变更与升级指南