正文

从0搭建CRM系统连接数据库到API接口Appsmith如何集成企业常用工具实现高效开发

/0 浏览量
0825

从0搭建CRM系统连接数据库到API接口Appsmith如何集成企业常用工具实现高效开发

嘿，朋友！看到标题你大概心里在想：这玩意儿听起来好复杂啊，我一个普通人能搞定吗？放心，我今天就是要把这件事掰开了、揉碎了讲给你听。咱们不整那些虚的，一步一步来，你跟着做，最后一定能让你的CRM系统跑起来。

先搞明白：CRM到底是个啥？

CRM，全称Customer Relationship Management（客户关系管理），说白了就是帮你管理客户信息的工具。你可以想象成一个超级智能的通讯录——不仅能记住客户的名字、电话、邮箱，还能记录每次沟通的内容、订单历史、付款情况，甚至能提醒你什么时候该回访客户。

为什么企业都需要它？因为销售团队天天跟客户打交道，信息散落在Excel、邮件、微信里，乱七八糟。CRM就是把这些信息统一收集、整理、分析的地方。

第一步：规划你的CRM长什么样

动手之前，先想清楚你要做什么。别一上来就写代码，那叫盲干。

核心功能模块

一个基础的CRM系统，通常需要这几个模块：

  • 客户管理：客户信息录入、编辑、搜索
  • 联系人管理：每个客户可能有多个联系人
  • 跟进记录：每次跟客户沟通的记录
  • 商机/订单管理：跟踪销售机会
  • 报表统计：销售数据、客户分析

技术选型

这里我给你推荐一个零代码/低代码的方案组合：

数据库：PostgreSQL（免费、功能强大）
后端API：Node.js + Express（轻量、灵活）
前端/管理界面：Appsmith（开源低代码平台）

为什么选这个组合？PostgreSQL是业界公认最可靠的开源数据库之一；Node.js写API简单快速；Appsmith能让你不用写太多前端代码就搭出一个漂亮的界面。最重要的是，这三样东西都免费，而且社区支持非常好。

第二步：搭建数据库

安装PostgreSQL

如果你用的是Mac，最简单的方式是用Homebrew：

brew install postgresql
brew services start postgresql

Windows用户可以去官网下载安装包，一路下一步就行。

安装完成后，创建数据库和几个核心表：

-- 创建数据库
CREATE DATABASE crm_db;

-- 切换到数据库
\c crm_db;

-- 客户表
CREATE TABLE customers (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    company VARCHAR(100),
    email VARCHAR(100) UNIQUE,
    phone VARCHAR(20),
    address TEXT,
    status VARCHAR(20) DEFAULT 'active',  -- active/inactive
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 联系人表
CREATE TABLE contacts (
    id SERIAL PRIMARY KEY,
    customer_id INTEGER REFERENCES customers(id) ON DELETE CASCADE,
    name VARCHAR(100) NOT NULL,
    position VARCHAR(100),
    email VARCHAR(100),
    phone VARCHAR(20),
    is_primary BOOLEAN DEFAULT FALSE
);

-- 跟进记录表
CREATE TABLE follow_ups (
    id SERIAL PRIMARY KEY,
    customer_id INTEGER REFERENCES customers(id) ON DELETE CASCADE,
    contact_id INTEGER REFERENCES contacts(id) ON DELETE SET NULL,
    follow_up_type VARCHAR(50),  -- call/email/meeting/visit
    content TEXT,
    scheduled_at TIMESTAMP,
    completed_at TIMESTAMP,
    status VARCHAR(20) DEFAULT 'pending',  -- pending/completed/cancelled
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 商机表
CREATE TABLE opportunities (
    id SERIAL PRIMARY KEY,
    customer_id INTEGER REFERENCES customers(id) ON DELETE CASCADE,
    title VARCHAR(200) NOT NULL,
    description TEXT,
    value DECIMAL(12,2),
    stage VARCHAR(50),  -- prospect/negotiation/closed-won/closed-lost
    probability INTEGER DEFAULT 0,
    expected_close_date DATE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 创建索引，加速查询
CREATE INDEX idx_customers_email ON customers(email);
CREATE INDEX idx_customers_company ON customers(company);
CREATE INDEX idx_opportunities_stage ON opportunities(stage);
CREATE INDEX idx_follow_ups_status ON follow_ups(status);

这些表之间的关系很简单：一个客户可以有多个联系人、多个跟进记录和多个商机。用外键把它们关联起来，数据就不会乱。

插入一些测试数据

-- 插入客户
INSERT INTO customers (name, company, email, phone, status) VALUES
('张三', 'ABC科技有限公司', 'zhangsan@abc.com', '13800138001', 'active'),
('李四', 'XYZ贸易公司', 'lisi@xyz.com', '13800138002', 'active'),
('王五', 'DEF教育集团', 'wangwu@def.com', '13800138003', 'inactive');

-- 插入联系人
INSERT INTO contacts (customer_id, name, position, email, phone, is_primary) VALUES
(1, '张三', 'CEO', 'zhangsan@abc.com', '13800138001', TRUE),
(2, '李四', '采购经理', 'lisi@xyz.com', '13800138002', TRUE),
(2, '赵六', '财务', 'zhaoliu@xyz.com', '13800138004', FALSE);

-- 插入商机
INSERT INTO opportunities (customer_id, title, description, value, stage, probability, expected_close_date) VALUES
(1, '年度软件采购', 'ABC科技需要采购100套企业授权', 50000.00, 'negotiation', 60, '2024-03-15'),
(2, '新员工培训系统', 'XYZ公司需要员工培训平台', 30000.00, 'prospect', 30, '2024-04-01');

-- 插入跟进记录
INSERT INTO follow_ups (customer_id, contact_id, follow_up_type, content, scheduled_at, status) VALUES
(1, 1, 'call', '电话沟通需求，客户对价格比较关注', '2024-01-20 14:00:00', 'completed'),
(2, 2, 'meeting', '线下拜访，演示了产品功能，客户感兴趣', '2024-01-22 10:00:00', 'completed'),
(1, 1, 'email', '发送了报价方案', '2024-01-25 09:00:00', 'pending');

第三步：用Node.js写API接口

现在数据库有了，接下来要写一个API层，让前端（Appsmith）能跟数据库对话。

初始化项目

mkdir crm-api && cd crm-api
npm init -y
npm install express pg cors dotenv
npm install --save-dev nodemon

在项目根目录创建 .env 文件，配置数据库连接：

PORT=3000
DB_HOST=localhost
DB_PORT=5432
DB_NAME=crm_db
DB_USER=postgres
DB_PASSWORD=your_password_here

创建 src/index.js：

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const { Pool } = require('pg');

const app = express();
const port = process.env.PORT || 3000;

// 中间件
app.use(cors());
app.use(express.json());

// 数据库连接池
const pool = new Pool({
    host: process.env.DB_HOST,
    port: parseInt(process.env.DB_PORT),
    database: process.env.DB_NAME,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
});

// 测试数据库连接
pool.query('SELECT NOW()')
    .then(res => console.log('数据库连接成功:', res.rows[0].now))
    .catch(err => console.error('数据库连接失败:', err.message));

// ==================== 客户接口 ====================

// 获取所有客户（支持搜索和分页）
app.get('/api/customers', async (req, res) => {
    try {
        const { page = 1, limit = 10, search = '' } = req.query;
        const offset = (page - 1) * limit;

        let sql = `
            SELECT c.*, COUNT(o.id) as opportunity_count,
                   SUM(CASE WHEN o.stage NOT IN ('closed-lost','closed-won') THEN o.value ELSE 0 END) as pipeline_value
            FROM customers c
            LEFT JOIN opportunities o ON c.id = o.customer_id
        `;
        const params = [];

        if (search) {
            sql += ` WHERE c.name ILIKE $${params.length + 1} OR c.company ILIKE $${params.length + 1} OR c.email ILIKE $${params.length + 1}`;
            params.push(`%${search}%`);
        }

        sql += ` GROUP BY c.id ORDER BY c.created_at DESC LIMIT $${params.length + 1} OFFSET $${params.length + 2}`;
        params.push(parseInt(limit), offset);

        const result = await pool.query(sql, params);

        // 获取总数
        let countSql = 'SELECT COUNT(*) FROM customers';
        const countParams = [];
        if (search) {
            countSql += ` WHERE name ILIKE $1 OR company ILIKE $1 OR email ILIKE $1`;
            countParams.push(`%${search}%`);
        }
        const countResult = await pool.query(countSql, countParams);

        res.json({
            data: result.rows,
            total: parseInt(countResult.rows[0].count),
            page: parseInt(page),
            limit: parseInt(limit)
        });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// 获取单个客户详情（含联系人、商机、跟进记录）
app.get('/api/customers/:id', async (req, res) => {
    try {
        const { id } = req.params;

        const customer = await pool.query(
            'SELECT * FROM customers WHERE id = $1', [id]
        );
        if (customer.rows.length === 0) {
            return res.status(404).json({ error: '客户不存在' });
        }

        const contacts = await pool.query(
            'SELECT * FROM contacts WHERE customer_id = $1 ORDER BY is_primary DESC', [id]
        );

        const opportunities = await pool.query(
            'SELECT * FROM opportunities WHERE customer_id = $1 ORDER BY created_at DESC', [id]
        );

        const followUps = await pool.query(
            `SELECT f.*, c.name as contact_name 
             FROM follow_ups f 
             LEFT JOIN contacts c ON f.contact_id = c.id 
             WHERE f.customer_id = $1 ORDER BY f.created_at DESC`, [id]
        );

        res.json({
            ...customer.rows[0],
            contacts: contacts.rows,
            opportunities: opportunities.rows,
            follow_ups: followUps.rows
        });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// 创建客户
app.post('/api/customers', async (req, res) => {
    try {
        const { name, company, email, phone, address, status } = req.body;

        const result = await pool.query(
            `INSERT INTO customers (name, company, email, phone, address, status)
             VALUES ($1, $2, $3, $4, $5, $6)
             RETURNING *`,
            [name, company, email, phone, address, status || 'active']
        );

        res.status(201).json(result.rows[0]);
    } catch (err) {
        if (err.code === '23505') {
            return res.status(400).json({ error: '邮箱已存在' });
        }
        res.status(500).json({ error: err.message });
    }
});

// 更新客户
app.put('/api/customers/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const { name, company, email, phone, address, status } = req.body;

        const result = await pool.query(
            `UPDATE customers 
             SET name=$1, company=$2, email=$3, phone=$4, address=$5, status=$6, updated_at=NOW()
             WHERE id=$7 RETURNING *`,
            [name, company, email, phone, address, status, id]
        );

        if (result.rows.length === 0) {
            return res.status(404).json({ error: '客户不存在' });
        }
        res.json(result.rows[0]);
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// 删除客户
app.delete('/api/customers/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const result = await pool.query('DELETE FROM customers WHERE id = $1 RETURNING *', [id]);

        if (result.rows.length === 0) {
            return res.status(404).json({ error: '客户不存在' });
        }
        res.json({ message: '删除成功' });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// ==================== 商机接口 ====================

app.get('/api/opportunities', async (req, res) => {
    try {
        const { stage, limit = 20 } = req.query;
        let sql = `
            SELECT o.*, c.name as customer_name, c.company
            FROM opportunities o
            JOIN customers c ON o.customer_id = c.id
        `;
        const params = [];

        if (stage) {
            sql += ` WHERE o.stage = $1`;
            params.push(stage);
        }

        sql += ` ORDER BY o.created_at DESC LIMIT $${params.length + 1}`;
        params.push(parseInt(limit));

        const result = await pool.query(sql, params);
        res.json(result.rows);
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

app.post('/api/opportunities', async (req, res) => {
    try {
        const { customer_id, title, description, value, stage, probability, expected_close_date } = req.body;

        const result = await pool.query(
            `INSERT INTO opportunities 
             (customer_id, title, description, value, stage, probability, expected_close_date)
             VALUES ($1, $2, $3, $4, $5, $6, $7)
             RETURNING *`,
            [customer_id, title, description, value, stage, probability, expected_close_date]
        );

        res.status(201).json(result.rows[0]);
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

app.patch('/api/opportunities/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const updates = req.body;
        const fields = Object.keys(updates)
            .filter(k => k !== 'id')
            .map((k, i) => `${k}=$${i + 1}`)
            .join(', ');
        const values = Object.values(updates);

        const result = await pool.query(
            `UPDATE opportunities SET ${fields}, updated_at=NOW() WHERE id=$${values.length + 1} RETURNING *`,
            [...values, id]
        );

        if (result.rows.length === 0) {
            return res.status(404).json({ error: '商机不存在' });
        }
        res.json(result.rows[0]);
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

// ==================== 统计接口 ====================

app.get('/api/stats/summary', async (req, res) => {
    try {
        const totalCustomers = await pool.query('SELECT COUNT(*) FROM customers');
        const activeCustomers = await pool.query("SELECT COUNT(*) FROM customers WHERE status='active'");
        const totalOpportunities = await pool.query('SELECT COUNT(*) FROM opportunities');
        const pipelineValue = await pool.query(
            "SELECT COALESCE(SUM(value), 0) as total FROM opportunities WHERE stage NOT IN ('closed-lost','closed-won')"
        );
        const closedWonValue = await pool.query(
            "SELECT COALESCE(SUM(value), 0) as total FROM opportunities WHERE stage='closed-won'"
        );
        const thisMonthNewCustomers = await pool.query(
            "SELECT COUNT(*) FROM customers WHERE created_at >= DATE_TRUNC('month', CURRENT_DATE)"
        );

        res.json({
            total_customers: parseInt(totalCustomers.rows[0].count),
            active_customers: parseInt(activeCustomers.rows[0].count),
            total_opportunities: parseInt(totalOpportunities.rows[0].count),
            pipeline_value: parseFloat(pipelineValue.rows[0].total),
            closed_won_value: parseFloat(closedWonValue.rows[0].total),
            this_month_new_customers: parseInt(thisMonthNewCustomers.rows[0].count)
        });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

app.listen(port, () => {
    console.log(`CRM API 运行在 http://localhost:${port}`);
});

启动服务：

npm run dev

现在你的API已经可以用了！你可以用Postman或者curl测试一下：

# 测试获取客户列表
curl http://localhost:3000/api/customers

# 测试创建客户
curl -X POST http://localhost:3000/api/customers \
  -H "Content-Type: application/json" \
  -d '{"name":"测试客户","company":"测试公司","email":"test@example.com","phone":"13900139000"}'

第四步：部署Appsmith

Appsmith是一个开源的低代码平台，它可以连接你的数据库和API，让你不用写前端代码就能搭出管理界面。

安装Appsmith

最简单的方式是用Docker：

git clone https://github.com/appsmithorg/appsmith.git
cd appsmith
docker-compose up -d

安装完成后，浏览器打开 http://localhost:8000，用管理员账号登录。

连接数据库

在Appsmith中，点击左侧菜单的 Datasources → New Datasource → 选择 PostgreSQL。

填入你的数据库信息：

  • Host: localhost（或者你数据库服务器的IP）
  • Port: 5432
  • Database: crm_db
  • Username: postgres
  • Password: 你设置的密码

点击 Test Connection，看到 Connection Successful 就证明连上了。

连接API

同样在 Datasources 中，选择 REST API，填写：

  • Base URL: http://localhost:3000/api

这样Appsmith就能调用你刚才写的Node.js接口了。

搭建界面

这是Appsmith最厉害的地方——拖拖拽拽就能出界面。

第一步：创建仪表盘页面

新建一个页面，命名为”仪表盘”。然后拖入以下组件：

  1. 卡片组件 — 显示关键数据（客户总数、商机总额等）
  2. 表格组件 — 显示客户列表
  3. 图表组件 — 显示销售趋势

对于卡片中的数据，我们直接绑定到刚才创建的API查询：

{{API_getSummary.data.pipeline_value | currency}}
{{API_getSummary.data.total_customers}}

第二步：创建客户列表页

拖一个表格组件，设置数据源为：

{{API_getCustomers.data.data}}

配置表格列：姓名、公司、邮箱、电话、状态、 pipeline价值。

在表格上方加一个搜索框，绑定到API的query参数：

API_getCustomers.run({
  page: 1,
  limit: 20,
  search: SearchInput.text
})

第三步：创建客户详情页

新建一个页面，拖入表单组件。设置默认值：

// 从URL参数获取客户ID
const customerId = queryParams.id;

// 当页面加载时获取客户详情
onPageLoad(() => {
    API_getCustomerById.run({
        pathParams: { id: customerId }
    });
});

表单各字段的默认值绑定：

CustomerName.defaultText = {{API_getCustomerById.data.name}}
Company.defaultText = {{API_getCustomerById.data.company}}
Email.defaultText = {{API_getCustomerById.data.email}}

在详情页下方，用子组件展示联系人、商机和跟进记录。

创建表单和弹窗

Appsmith的强大之处在于，它支持用JS表达式动态控制界面。比如，当你点击”新建客户”按钮时弹出一个模态框：

// 按钮的onClick事件
Modal_createCustomer.isVisible = true;
Form_createCustomer.reset();

表单提交时：

// 表单的onSubmit事件
API_createCustomer.run({
    body: {
        name: Form_createCustomer.name,
        company: Form_createCustomer.company,
        email: Form_createCustomer.email,
        phone: Form_createCustomer.phone,
        address: Form_createCustomer.address,
        status: Form_createCustomer.status
    }
}).then(() => {
    Modal_createCustomer.isVisible = false;
    API_getCustomers.run();  // 刷新列表
    showAlert('客户创建成功！', 'success');
});

第五步：集成企业常用工具

一个真正的企业级CRM，不能孤立存在，要跟公司已有的工具打通。

集成企业微信/钉钉

很多公司用企业微信或钉钉沟通，Appsmith支持通过webhook发送消息：

// 当商机状态变更时，自动通知销售
function notifyOnStageChange(newStage) {
    if (newStage === 'closed-won') {
        // 发送企业微信消息
        http Post({
            url: 'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY',
            body: {
                msgtype: 'text',
                text: {
                    content: `🎉 恭喜！商机 ${opportunityTitle} 已成交，金额：${value}元`
                }
            }
        });
    }
}

集成邮件系统

用Nodemailer在CRM里直接发邮件：

// 在API层添加邮件发送接口
const nodemailer = require('nodemailer');

const transporter = nodemailer.createTransport({
    host: 'smtp.qq.com',
    port: 587,
    auth: {
        user: process.env.SMTP_USER,
        pass: process.env.SMTP_PASS
    }
});

app.post('/api/send-email', async (req, res) => {
    try {
        const { to, subject, html } = req.body;
        await transporter.sendMail({
            from: '"CRM系统" <noreply@yourcompany.com>',
            to,
            subject,
            html
        });
        res.json({ success: true });
    } catch (err) {
        res.status(500).json({ error: err.message });
    }
});

集成日历

在CRM中标记跟进时间，可以和Google Calendar或Outlook Calendar同步：

// 当创建跟进记录时，同时创建日历事件
app.post('/api/follow-ups', async (req, res) => {
    const { customer_id, contact_id, follow_up_type, content, scheduled_at } = req.body;

    // 插入数据库
    const result = await pool.query(
        `INSERT INTO follow_ups (customer_id, contact_id, follow_up_type, content, scheduled_at)
         VALUES ($1, $2, $3, $4, $5) RETURNING *`,
        [customer_id, contact_id, follow_up_type, content, scheduled_at]
    );

    // 同时创建日历事件（以Google Calendar为例）
    try {
        await calendar.events.insert({
            calendarId: 'primary',
            resource: {
                summary: `${follow_up_type} - 客户跟进`,
                description: content,
                start: { dateTime: scheduled_at },
                end: { dateTime: new Date(new Date(scheduled_at).getTime() + 3600000).toISOString() }
            }
        });
    } catch (err) {
        console.error('日历创建失败:', err);
    }

    res.status(201).json(result.rows[0]);
});

集成飞书/Slack机器人

对于用飞书或Slack的团队，可以创建一个机器人，把CRM的关键信息推送过去：

// 每日销售日报推送
app.get('/api/daily-report', async (req, res) => {
    const today = new Date().toISOString().split('T')[0];

    const newOpportunities = await pool.query(
        "SELECT title, value, customer_id FROM opportunities WHERE DATE(created_at) = $1",
        [today]
    );

    const pendingFollowUps = await pool.query(
        `SELECT f.*, c.name as customer_name 
         FROM follow_ups f 
         JOIN customers c ON f.customer_id = c.id 
         WHERE f.status = 'pending' AND DATE(f.scheduled_at) = $1`,
        [today]
    );

    // 推送到Slack
    await slack.chat.postMessage({
        channel: '#sales',
        text: `📊 今日CRM日报\n\n` +
              `新增商机: ${newOpportunities.rows.length} 个\n` +
              `待跟进记录: ${pendingFollowUps.rows.length} 条\n\n` +
              `🔗 查看详情: https://crm.yourcompany.com`
    });

    res.json({ sent: true });
});

第六步：部署上线

本地开发完成后，要把系统部署到服务器上。

部署API

推荐使用 PM2 管理Node.js进程：

npm install -g pm2

# 启动服务
pm2 start src/index.js --name crm-api

# 设置开机自启
pm2 save
pm2 startup

用 Nginx 做反向代理：

server {
    listen 80;
    server_name crm-api.yourcompany.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

部署Appsmith

Appsmith官方提供了多种部署方式，推荐用Docker Compose部署到云服务器：

version: '3.8'
services:
  appsmith:
    image: index.docker.io/appsmith/ee:latest
    container_name: appsmith
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./stacks:/appsmith-stacks
    environment:
      - PUBLIC_URL=https://crm.yourcompany.com
      - INSTALLATION_SETUP_ADMIN_USER_EMAIL=admin@yourcompany.com
      - INSTALLATION_SETUP_ADMIN_USER_PASSWORD=your_strong_password
    restart: unless-stopped

第七步：安全加固

上线前，安全一定要做好：

// 添加基础认证中间件
const jwt = require('jsonwebtoken');

const authenticate = (req, res, next) => {
    const token = req.headers.authorization?.split(' ')[1];
    if (!token) {
        return res.status(401).json({ error: '未授权' });
    }
    try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        req.user = decoded;
        next();
    } catch (err) {
        return res.status(403).json({ error: '令牌无效' });
    }
};

// 应用认证中间件
app.use('/api', authenticate);

// 输入验证
const { body, param, query, validationResult } = require('express-validator');

app.post('/api/customers', [
    body('name').trim().notEmpty().isLength({ min: 1, max: 100 }),
    body('email').isEmail().normalizeEmail(),
    body('phone').optional().isMobilePhone('zh-CN')
], async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    // ... 处理逻辑
});

一些实战中的小经验

跟你说几个实际做这个项目时踩过的坑：

坑一：数据库连接池要配置 刚开始我没配连接池，直接用 new Client() 每次查询都新建连接，用户一多就崩了。改成 Pool 之后，并发几百个请求都没问题。

坑二：API要统一返回格式 统一用 { code: 200, data: ..., message: '...' } 这样的格式，前端解析起来非常方便。别一会儿返回数组，一会儿返回对象。

坑三：Appsmith的API调用缓存 Appsmith默认会缓存API结果，如果你希望数据实时更新，需要在API设置里关掉缓存，或者用 run({ forceRun: true }) 强制刷新。

坑四：大表查询要加索引 客户数据量大了之后（超过1万条），搜索会变得很慢。给经常查询的字段加索引能大幅提升性能。前面建表时我已经加了几个常用索引，你可以根据实际情况再加。

坑五：定时任务要靠谱 如果需要每日推送日报之类的功能，别用 setInterval，服务器重启就没了。用PM2的cron功能或者系统的crontab更稳：

# 每天早上9点生成日报
0 9 * * * cd /opt/crm-api && /usr/bin/node src/daily-report.js >> /var/log/crm-cron.log 2>&1

最后的话

到这里，你的CRM系统从数据库到API到Appsmith界面，再到各种企业工具的集成，都已经跑通了。整个流程可能看起来有点多，但核心就三件事：存数据（数据库）、处理数据（API）、展示数据（Appsmith）。

记住，不要追求一步到位。先搭出一个能用的最小版本，让团队用起来，然后根据实际反馈不断迭代。一个好的CRM系统是”长”出来的，不是”设计”出来的。

有什么具体问题，随时来问！

-- 展开阅读全文 --