Node.js 开发项目

初始化

npm init

## 
npm install 

编辑packege.json 添加，以支持ES6的语法

"type": "module"

连接mysql示例

import db from './db/ops_mysql.js'

const createTable = async () => {
  const insert_data = `
    CREATE TABLE IF NOT EXISTS users (
      id INT AUTO_INCREMENT PRIMARY KEY,
      username VARCHAR(255) NOT NULL,
      password VARCHAR(255) NOT NULL
    );
  `;

  try {
    await db.query(createTableSQL);
    console.log('Table `users` created successfully.');
  } catch (error) {
    console.error('Error creating table:', error);
  } finally {
    await db.end();
  }
};

const insertData = async () => {
  const insert_data = `
    INSERT INTO users (username, password) VALUES ('knight', '112233');
  `;

  try {
    await db.query(insert_data);
    console.log('Data inserted successfully into `users` table.');
  } catch (error) {
    console.error('Error inserting data:', error);
  } finally {
    await db.end();
  }
};

// createTable();

// insertData();

http请求示例

import fetch, { Response } from "node-fetch";
// 发送get请求


const fetchData =  async(userid)=>{
    const url = `https://jsonplaceholder.typicode.com/posts?userId=${userid}`;
    const res = await fetch(url);
    // const data = await res.json();
    /*
    在你的代码中，res.json() 返回的是一个 Promise 对象，而不是直接的数据。如果你在调用 res.json() 前不加 await，
    你实际上是在处理一个 Promise，而不是获取到 JSON 数据
    使用 await：当你在前面加上 await 时，代码会暂停执行，直到 Promise 完成并返回解析后的数据。
    
    */
    const data =  res.json();   
    console.log(data)     

};

fetchData(1)

读取json配置文件

import fs from 'fs/promises';

async function loadConfig(){

    const data  = await fs.readFile('conf/config.json','utf-8');
    const config = JSON.parse(data);
    console.log(config);
    console.log(config.database['host']);

}

loadConfig();

Express 项目开发

依赖

D:\js-res\knight_res>npm list
devops@1.0.0 D:\js-res\knight_res
+-- @elastic/elasticsearch@7.17.14
+-- express@5.1.0
+-- mysql2@3.14.0
+-- node-fetch@3.3.2
+-- puppeteer@24.7.2
`-- sync-mysql@3.0.1

web.js

import express, { Router } from 'express';
import router from './router.js';


const app = express();

const port  = process.env.port || 3000;
console.log(port);
app.listen(port,()=>{
    console.log("running....");
})

app.use(router);
// 静态资源路径
app.use(express.static('static'));
app.use(express.static('public'));

router.js

import express from 'express';
import {query_data_main,id_query_data_main} from './db/ops_mysql.js'
import {ES_DataMain,ES_RW} from './db/ops_es.js'

const router = express.Router();


router.get('/user',(req,res)=>{
    res.send({'name':'rose','age':30})
})

router.get('/{a*bcd}', async(req, res) => {
    res.send('ab?cd')
  })
  
router.get('/user/:id',(req,res,next)=>{
    console.log('Request URL:', req.originalUrl)
    res.send('USER')
})
// check mysql
router.get('/list_data',(req,res)=>{
    res.send(query_data_main())
})

router.get('/list_data/:id',(req,res)=>{
    const id = req.params.id;
    console.log(id);
    res.send(id_query_data_main(id))
})

// es read
router.get('/list_es_data',async(req,res)=>{
    const  body_sql = {
        query: {
            match_all: {}
        }
    }

    const data = await ES_DataMain(body_sql);
    res.send(data);
})

// es read for title
router.get('/list_es_data_title',async(req,res)=>{
    const  body_sql = {
        query: {
            "match": {
                "title": "test"
              }
        }
    }

    const data = await ES_DataMain(body_sql);
    res.send(data);
})

// 写入数据
router.get('/rw_es_data/:name/:age',async(req,res)=>{
    const name = req.params.name;
    const age = req.params.age;
    const  body_sql = {
        name: name,
        age: age
    }
    const data = await ES_RW(body_sql);
    res.send("sucess");
})


export default router;

ops_mysql.js

import mysql from 'sync-mysql';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';

// 获取当前模块的目录名
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const configPath = path.join(__dirname, '../conf/config.json');

// 同步加载配置
function loadConfig() {
    try {
        const data = fs.readFileSync(configPath, 'utf-8'); // 使用同步读取
        return JSON.parse(data)['mysql_info'];
    } catch (error) {
        console.error('Error reading config file:', error);
        throw error;
    }
}

// 创建 MySQL 连接
function createConnection() {
    const mysql_config = loadConfig(); // 同步获取配置
    return new mysql({
        host: mysql_config['host'],
        user: mysql_config['user'],
        password: mysql_config['password'],
        database: mysql_config['database']
    });
}

// 同步查询数据
function query_data(connection) {
    try {
        let sql = 'SELECT * FROM users;'
        const rows = connection.query(sql);
        // console.log(rows);
        return rows;
    } catch (error) {
        console.error('Error executing query:', error);
    }
}

 // 根据id 查询
 function id_query_data(connection,id){
    let sql = `SELECT * FROM users where id = ${id};`
    const rows = connection.query(sql);
    return rows;
 }

// 主查询函数
function query_data_main() {
    const connection = createConnection();
    const data = query_data(connection);
    console.log(data);
    return data;
}


function id_query_data_main(id) {
    const connection = createConnection();
    const data = id_query_data(connection,id);
    return data;
}
// 导出函数
export { loadConfig, createConnection, query_data_main,id_query_data_main };

// 执行查询
query_data_main();

ops_es.js

import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import { Client } from '@elastic/elasticsearch'; 

// 获取当前模块的目录名
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const configPath = path.join(__dirname, '../conf/config.json');

// 同步加载配置
function loadConfig() {
    try {
        const data = fs.readFileSync(configPath, 'utf-8'); // 使用同步读取
        // console.log(data["es_info"]);
        const data_2 = JSON.parse(data);
        console.log(data_2["es_info"]);
        return (data_2["es_info"]);
    } catch (error) {
        console.error('Error reading config file:', error);
        throw error;
    }
}

// 创建 Elasticsearch 客户端
function createClient() {
    const es_config = loadConfig();
    console.log(es_config);
    return new Client({ node: es_config["host"] });
}

// 读取所有数据,异步读取
async function queryData(client,body_sql) {
    const { body } = await client.search({
        index: 'my_index', // 替换为你的索引名称
        body: body_sql
    });
    return body.hits.hits; // 返回查询结果
}

// 写入数据
async function writeData(client,body_sql){
    const response = await client.index({
        index : 'my_index',
        body: body_sql
    })

}


async function ES_DataMain(body_sql) {
    const client = createClient();
    const data = await queryData(client,body_sql);
    console.log(data); // 输出查询结果
    return data; // 返回结果
}


async function ES_RW(body_sql) {
    const client = createClient();
    const data = await writeData(client,body_sql);
    console.log(data); // 输出查询结果
    return data; // 返回结果
}

export { ES_DataMain,ES_RW };