Odoo Python 开发：初学者和专业人士的完整指南

根据 2025 年 Python 开发人员调查，超过 47% 的企业 Python 开发人员至少使用一种 ERP 框架，而 Odoo 在开源 ERP 中以 68% 的市场份额占据主导地位。无论您是构建第一个模块还是构建多公司部署，了解 Odoo 的 Python 层都是您可以开发的最有影响力的技能。

本指南远远超出了表面概述。我们将逐步介绍 Odoo 的 Python 后端的每一层 - 从 ORM 的元类魔法到高级控制器模式，从调试生产问题到编写实际捕获回归的测试。

要点

• Odoo 的 ORM 是一个完整的对象关系映射器，构建于元类之上，可自动生成 SQL 模式、管理缓存并处理多公司安全性 — 深入理解它是使用 Odoo 和对抗它的区别。
• 五个字段类别涵盖所有数据建模需求：基本（字符、整数、浮点、布尔、文本、Html、日期、日期时间、二进制、选择）、关系（Many2one、One2many、Many2many）、计算、相关和货币字段。
• 三种继承机制让您无需分叉即可扩展 Odoo 的任何部分：类继承 (_inherit)、原型继承 (_inherit + _name) 和委托继承 (_inherits)。
• 控制器使用装饰器 (@http.route) 以及 JSON-RPC 和 HTTP 端点模式、身份验证模式和 CORS 配置来处理 HTTP。
• 使用 TransactionCase 和 HttpCase 进行自动化测试，在回归投入生产之前捕获它们 - 目标是业务逻辑覆盖率超过 80%。

1. 设置您的开发环境

在编写代码之前，您需要一个合适的开发环境。以下是 2026 年的建议设置：

# Install system dependencies (Ubuntu/Debian)
# sudo apt install python3.12 python3.12-venv python3.12-dev
# sudo apt install postgresql-17 libpq-dev libxml2-dev libxslt1-dev

# Clone Odoo source (enterprise requires license)
# git clone https://github.com/odoo/odoo.git --branch 18.0 --depth 1
# git clone https://github.com/odoo/enterprise.git --branch 18.0 --depth 1

# Create virtual environment
# python3.12 -m venv odoo-venv
# source odoo-venv/bin/activate
# pip install -r odoo/requirements.txt

# Create database and start Odoo
# createdb mydb
# python odoo/odoo-bin -d mydb --addons-path=odoo/addons,enterprise,custom_addons

为您的模块创建一个 custom_addons 目录。每个模块都位于其自己的子目录中，具有 Odoo 期望的特定结构。

2. 模块架构深入探讨

每个 Odoo 模块都遵循约定优于配置的结构。了解每个组件的作用至关重要：

my_module/
├── __init__.py              # Python package initializer
├── __manifest__.py          # Module metadata and dependencies
├── models/
│   ├── __init__.py
│   ├── sale_order.py        # Business logic models
│   └── res_partner.py       # Partner extensions
├── views/
│   ├── sale_order_views.xml # Form, tree, search views
│   └── menu.xml             # Menu items and actions
├── controllers/
│   ├── __init__.py
│   └── main.py              # HTTP controllers
├── security/
│   ├── ir.model.access.csv  # ACL rules
│   └── security.xml         # Record rules and groups
├── data/
│   ├── data.xml             # Default data
│   └── demo.xml             # Demo data (dev only)
├── wizards/
│   ├── __init__.py
│   └── mass_update.py       # TransientModel wizards
├── report/
│   ├── report_invoice.xml   # QWeb report templates
│   └── report.py            # Report parsers
├── static/
│   ├── description/
│   │   └── icon.png         # Module icon (128x128)
│   └── src/
│       ├── js/              # OWL components
│       └── xml/             # OWL templates
└── tests/
    ├── __init__.py
    └── test_sale_order.py   # Automated tests

清单文件

__manifest__.py 是模块的核心。每个领域都很重要：

# __manifest__.py
{
    'name': 'Sales Commission Engine',
    'version': '18.0.1.0.0',        # Odoo version.major.minor.patch
    'category': 'Sales/Commission',
    'summary': 'Automated commission calculations for sales teams',
    'description': """
        Long description with RST formatting.
        Supports multi-tier commission plans.
    """,
    'author': 'ECOSIRE Private Limited',
    'website': 'https://ecosire.com',
    'license': 'LGPL-3',
    'depends': ['sale', 'account', 'hr'],  # Required modules
    'data': [
        'security/ir.model.access.csv',
        'views/commission_plan_views.xml',
        'views/menu.xml',
        'data/commission_data.xml',
    ],
    'demo': ['data/demo.xml'],
    'installable': True,
    'application': True,              # Shows in Apps menu
    'auto_install': False,
    'external_dependencies': {
        'python': ['pandas'],          # pip packages
    },
}

版本编号约定： {odoo_version}.{major}.{minor}.{patch} — 第一个数字始终与 Odoo 系列匹配。

3. ORM API：完整参考

Odoo 的 ORM 比大多数开发人员意识到的要强大得多。它自动处理模式生成、缓存、访问控制和多公司过滤。

模型类型

from odoo import models, fields, api

# Persistent model — stored in database
class CommissionPlan(models.Model):
    _name = 'commission.plan'
    _description = 'Commission Plan'
    _order = 'sequence, name'
    _rec_name = 'name'

    name = fields.Char(string='Plan Name', required=True, index=True)
    active = fields.Boolean(default=True)
    sequence = fields.Integer(default=10)
    company_id = fields.Many2one('res.company', default=lambda self: self.env.company)

# Transient model — auto-cleaned after ~1 hour
class CommissionWizard(models.TransientModel):
    _name = 'commission.calculate.wizard'
    _description = 'Calculate Commissions'

    date_from = fields.Date(required=True)
    date_to = fields.Date(required=True)

# Abstract model — no database table, only for inheritance
class CommissionMixin(models.AbstractModel):
    _name = 'commission.mixin'
    _description = 'Commission Mixin'

    commission_rate = fields.Float(string='Commission %')

字段类型深入探讨

class SaleCommission(models.Model):
    _name = 'sale.commission'
    _description = 'Sale Commission Record'

    # Basic fields
    name = fields.Char(string='Reference', required=True, copy=False,
                       default=lambda self: self.env['ir.sequence'].next_by_code('sale.commission'))
    amount = fields.Float(string='Amount', digits=(16, 2))
    percentage = fields.Float(string='Rate %', digits=(5, 2))
    is_paid = fields.Boolean(string='Paid', default=False)
    notes = fields.Text(string='Internal Notes')
    description = fields.Html(string='Description', sanitize=True)
    date = fields.Date(string='Commission Date', default=fields.Date.today)
    create_datetime = fields.Datetime(string='Created', default=fields.Datetime.now)
    document = fields.Binary(string='Attachment')
    document_name = fields.Char(string='File Name')

    # Selection field
    state = fields.Selection([
        ('draft', 'Draft'),
        ('confirmed', 'Confirmed'),
        ('paid', 'Paid'),
        ('cancelled', 'Cancelled'),
    ], string='Status', default='draft', tracking=True)

    # Relational fields
    salesperson_id = fields.Many2one('res.users', string='Salesperson',
                                      required=True, ondelete='restrict')
    order_id = fields.Many2one('sale.order', string='Sale Order')
    line_ids = fields.One2many('sale.commission.line', 'commission_id', string='Lines')
    tag_ids = fields.Many2many('sale.commission.tag', string='Tags')

    # Computed field with store and search
    total_amount = fields.Monetary(string='Total', compute='_compute_total',
                                    store=True, currency_field='currency_id')
    currency_id = fields.Many2one('res.currency', related='company_id.currency_id')

    @api.depends('line_ids.amount')
    def _compute_total(self):
        for record in self:
            record.total_amount = sum(record.line_ids.mapped('amount'))

    # Related field (shortcut for computed)
    salesperson_email = fields.Char(related='salesperson_id.email', store=True)

CRUD 操作

# CREATE — returns new recordset
commission = self.env['sale.commission'].create({
    'salesperson_id': self.env.user.id,
    'order_id': order.id,
    'state': 'draft',
    'line_ids': [
        (0, 0, {'product_id': product.id, 'amount': 150.00}),  # Create
    ],
})

# Batch create (much faster than loop)
vals_list = [{'name': f'COM-{i}', 'amount': i * 10} for i in range(100)]
records = self.env['sale.commission'].create(vals_list)

# READ — browse by IDs
commission = self.env['sale.commission'].browse(42)
commissions = self.env['sale.commission'].browse([42, 43, 44])

# SEARCH — returns recordset matching domain
pending = self.env['sale.commission'].search([
    ('state', '=', 'confirmed'),
    ('date', '>=', '2026-01-01'),
    ('salesperson_id.department_id.name', '=', 'Sales'),
], order='date desc', limit=50)

# search_count — just the count
count = self.env['sale.commission'].search_count([('state', '=', 'draft')])

# search_read — search + read in one query (optimal for API calls)
data = self.env['sale.commission'].search_read(
    [('state', '=', 'confirmed')],
    fields=['name', 'amount', 'salesperson_id'],
    limit=20, offset=0, order='amount desc'
)

# UPDATE
commission.write({'state': 'paid', 'notes': 'Paid on March 2026'})

# Batch update (all records get same values)
pending.write({'state': 'confirmed'})

# DELETE
old_drafts.unlink()

# SPECIAL: (0, 0, vals) create, (1, id, vals) update, (2, id, 0) delete
# (3, id, 0) unlink M2M, (4, id, 0) link M2M, (5, 0, 0) clear M2M
# (6, 0, [ids]) replace M2M

域表达式

域是 Odoo 的查询语言。掌握它们：

# Basic operators: =, !=, >, >=, <, <=, like, ilike, in, not in
# Special operators: =like (SQL LIKE), =ilike (case-insensitive LIKE)
# child_of, parent_of — for hierarchical models

domain = [
    '|',                                    # OR (next two leaves)
        ('state', '=', 'confirmed'),
        '&',                                # AND (next two leaves)
            ('state', '=', 'draft'),
            ('amount', '>', 1000),
    ('salesperson_id', '!=', False),        # Implicit AND with above
    ('date', '>=', '2026-01-01'),
    ('tag_ids.name', 'in', ['priority', 'vip']),  # Dot notation for relations
]

# Negation
domain = [('state', 'not in', ['cancelled', 'paid'])]

# NULL checks
domain = [('notes', '!=', False)]  # Has notes
domain = [('notes', '=', False)]   # No notes

4. 继承模式

Odoo 提供了三种继承机制，使您可以扩展任何模块而无需修改其源代码。类继承向现有模型添加字段和方法。原型继承基于具有单独数据库表的现有模型创建新模型。委托继承通过组合链接模型，自动在两个表中创建记录。

类继承（最常见）

class SaleOrderInherit(models.Model):
    _inherit = 'sale.order'  # Extend existing model

    # Add new fields
    commission_plan_id = fields.Many2one('commission.plan', string='Commission Plan')
    commission_amount = fields.Monetary(compute='_compute_commission')

    @api.depends('amount_total', 'commission_plan_id.rate')
    def _compute_commission(self):
        for order in self:
            rate = order.commission_plan_id.rate or 0
            order.commission_amount = order.amount_total * rate / 100

    # Override existing method
    def action_confirm(self):
        res = super().action_confirm()  # Always call super()
        for order in self:
            if order.commission_plan_id:
                order._create_commission_record()
        return res

    def _create_commission_record(self):
        self.ensure_one()
        self.env['sale.commission'].create({
            'order_id': self.id,
            'salesperson_id': self.user_id.id,
            'amount': self.commission_amount,
        })

原型继承

class ProjectCommission(models.Model):
    _name = 'project.commission'
    _inherit = 'sale.commission'  # Copy structure to new model
    _description = 'Project-based Commission'

    # Has all fields from sale.commission PLUS its own table
    project_id = fields.Many2one('project.project', required=True)
    milestone_id = fields.Many2one('project.milestone')

委托继承

class CommissionEmployee(models.Model):
    _name = 'commission.employee'
    _inherits = {'hr.employee': 'employee_id'}  # Delegation
    _description = 'Commission-eligible Employee'

    employee_id = fields.Many2one('hr.employee', required=True, ondelete='cascade')
    commission_plan_id = fields.Many2one('commission.plan')
    lifetime_earnings = fields.Monetary()

    # Can access employee fields directly: record.name, record.department_id

5. 业务逻辑模式

约束

from odoo.exceptions import ValidationError

class CommissionPlan(models.Model):
    _name = 'commission.plan'

    rate = fields.Float(required=True)
    name = fields.Char(required=True)

    # Python constraint
    @api.constrains('rate')
    def _check_rate(self):
        for plan in self:
            if not 0 <= plan.rate <= 100:
                raise ValidationError(
                    f"Commission rate must be between 0 and 100. Got: {plan.rate}"
                )

    # SQL constraint (faster, database-level)
    _sql_constraints = [
        ('name_unique', 'UNIQUE(name, company_id)',
         'Commission plan name must be unique per company.'),
        ('rate_positive', 'CHECK(rate >= 0)',
         'Commission rate must be positive.'),
    ]

Onchange 方法

@api.onchange('commission_plan_id')
def _onchange_plan(self):
    """Triggered in UI when field changes. Sets defaults and warnings."""
    if self.commission_plan_id:
        self.percentage = self.commission_plan_id.rate
        if self.commission_plan_id.rate > 30:
            return {
                'warning': {
                    'title': 'High Commission Rate',
                    'message': 'This plan has a rate above 30%. Please confirm with management.',
                }
            }

状态机工作流程

class SaleCommission(models.Model):
    _name = 'sale.commission'

    state = fields.Selection([
        ('draft', 'Draft'),
        ('confirmed', 'Confirmed'),
        ('approved', 'Approved'),
        ('paid', 'Paid'),
        ('cancelled', 'Cancelled'),
    ], default='draft', tracking=True)

    def action_confirm(self):
        for rec in self.filtered(lambda r: r.state == 'draft'):
            rec.state = 'confirmed'
            rec.message_post(body="Commission confirmed.")

    def action_approve(self):
        self.filtered(lambda r: r.state == 'confirmed').write({
            'state': 'approved',
            'approved_by': self.env.user.id,
            'approved_date': fields.Datetime.now(),
        })

    def action_pay(self):
        for rec in self.filtered(lambda r: r.state == 'approved'):
            rec._process_payment()
            rec.state = 'paid'

    def action_cancel(self):
        allowed = self.filtered(lambda r: r.state in ('draft', 'confirmed'))
        allowed.write({'state': 'cancelled'})

6. 控制器和 HTTP 端点

from odoo import http
from odoo.http import request, Response
import json

class CommissionController(http.Controller):

    # JSON-RPC endpoint (used by Odoo's internal JS framework)
    @http.route('/commission/calculate', type='json', auth='user', methods=['POST'])
    def calculate_commission(self, order_id, **kwargs):
        order = request.env['sale.order'].browse(order_id)
        if not order.exists():
            return {'error': 'Order not found'}
        commission = order.commission_amount
        return {'order_id': order_id, 'commission': commission}

    # HTTP endpoint (REST-style, for external integrations)
    @http.route('/api/v1/commissions', type='http', auth='api_key',
                methods=['GET'], csrf=False)
    def list_commissions(self, **kwargs):
        domain = [('state', '!=', 'cancelled')]
        if kwargs.get('salesperson_id'):
            domain.append(('salesperson_id', '=', int(kwargs['salesperson_id'])))

        commissions = request.env['sale.commission'].search_read(
            domain,
            fields=['name', 'amount', 'state', 'date'],
            limit=int(kwargs.get('limit', 50)),
            offset=int(kwargs.get('offset', 0)),
        )

        return Response(
            json.dumps({'data': commissions, 'count': len(commissions)}),
            content_type='application/json',
            status=200,
        )

    # File download endpoint
    @http.route('/commission/report/<int:commission_id>', type='http', auth='user')
    def download_report(self, commission_id, **kwargs):
        commission = request.env['sale.commission'].browse(commission_id)
        pdf = request.env['ir.actions.report']._render_qweb_pdf(
            'my_module.commission_report', commission.ids
        )
        return request.make_response(
            pdf[0],
            headers=[
                ('Content-Type', 'application/pdf'),
                ('Content-Disposition', f'attachment; filename=commission_{commission_id}.pdf'),
            ]
        )

身份验证模式

7. 安全性：ACL 和记录规则

访问控制列表 (ir.model.access.csv)

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_commission_user,commission.user,model_sale_commission,sales_team.group_sale_salesman,1,0,0,0
access_commission_manager,commission.manager,model_sale_commission,sales_team.group_sale_manager,1,1,1,0
access_commission_admin,commission.admin,model_sale_commission,base.group_system,1,1,1,1

记录规则（security.xml）

<record id="commission_own_rule" model="ir.rule">
    <field name="name">Salesperson sees own commissions</field>
    <field name="model_id" ref="model_sale_commission"/>
    <field name="groups" eval="[(4, ref('sales_team.group_sale_salesman'))]"/>
    <field name="domain_force">[('salesperson_id', '=', user.id)]</field>
</record>

<record id="commission_company_rule" model="ir.rule">
    <field name="name">Company-level commission isolation</field>
    <field name="model_id" ref="model_sale_commission"/>
    <field name="global" eval="True"/>
    <field name="domain_force">[('company_id', 'in', company_ids)]</field>
</record>

8. 调试技巧

使用 Odoo Shell

# Start interactive shell with full ORM access
python odoo-bin shell -d mydb --addons-path=addons,custom_addons

# In shell:
>>> orders = env['sale.order'].search([('state', '=', 'sale')], limit=5)
>>> for o in orders:
...     print(f"{o.name}: {o.amount_total} - {o.partner_id.name}")
>>> env.cr.commit()  # Commit changes made in shell

日志记录

import logging
_logger = logging.getLogger(__name__)

class SaleCommission(models.Model):
    _name = 'sale.commission'

    def action_confirm(self):
        _logger.info("Confirming commission %s for user %s", self.name, self.env.user.name)
        try:
            self._validate_commission()
        except Exception as e:
            _logger.exception("Failed to confirm commission %s: %s", self.name, e)
            raise

性能分析

# Enable SQL logging in odoo.conf:
# log_level = debug_sql

# Or use the profiler decorator
from odoo.tools.profiler import profile

@profile('/tmp/commission_profile')
def action_bulk_calculate(self):
    # This will generate a profile dump you can analyze
    for order in self.env['sale.order'].search([]):
        order._calculate_commission()

常见的性能缺陷：

• 访问循环中的关系字段（N+1 查询）——使用 read() 或 mapped() 代替
• 在循环内调用 search() — 批量搜索
• 在频繁过滤的计算字段上不使用 store=True
• 忘记 sudo() 会导致对每个操作进行额外的访问权限检查

9. 自动化测试

from odoo.tests.common import TransactionCase, HttpCase, tagged
from odoo.exceptions import ValidationError

@tagged('post_install', '-at_install')
class TestCommission(TransactionCase):

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        cls.partner = cls.env['res.partner'].create({'name': 'Test Customer'})
        cls.user = cls.env['res.users'].create({
            'name': 'Test Salesperson',
            'login': 'test_sales',
            'groups_id': [(4, cls.env.ref('sales_team.group_sale_salesman').id)],
        })
        cls.plan = cls.env['commission.plan'].create({
            'name': 'Standard 10%',
            'rate': 10.0,
        })

    def test_commission_calculation(self):
        """Commission amount should be 10% of order total."""
        order = self.env['sale.order'].create({
            'partner_id': self.partner.id,
            'user_id': self.user.id,
            'commission_plan_id': self.plan.id,
        })
        # Add order line...
        self.assertAlmostEqual(order.commission_amount, 100.0, places=2)

    def test_rate_constraint(self):
        """Rates above 100 should raise ValidationError."""
        with self.assertRaises(ValidationError):
            self.env['commission.plan'].create({
                'name': 'Invalid Plan',
                'rate': 150.0,
            })

    def test_state_machine(self):
        """Commission should follow draft -> confirmed -> paid flow."""
        commission = self.env['sale.commission'].create({
            'salesperson_id': self.user.id,
            'amount': 500,
        })
        self.assertEqual(commission.state, 'draft')
        commission.action_confirm()
        self.assertEqual(commission.state, 'confirmed')


# HTTP/Tour tests
@tagged('post_install', '-at_install')
class TestCommissionTour(HttpCase):

    def test_commission_dashboard(self):
        """Test that the commission dashboard loads correctly."""
        self.start_tour('/web#action=commission.action_dashboard',
                       'commission_dashboard_tour', login='admin')

运行测试：

# Run all tests for a module
python odoo-bin -d testdb -i my_module --test-enable --stop-after-init

# Run specific test class
python odoo-bin -d testdb --test-tags /my_module:TestCommission --stop-after-init

# Run with coverage
coverage run odoo-bin -d testdb -i my_module --test-enable --stop-after-init
coverage report --include="custom_addons/my_module/*"

10. 高级模式

计划操作（Cron 作业）

<record id="ir_cron_monthly_commission" model="ir.cron">
    <field name="name">Calculate Monthly Commissions</field>
    <field name="model_id" ref="model_sale_commission"/>
    <field name="state">code</field>
    <field name="code">model._cron_calculate_monthly()</field>
    <field name="interval_number">1</field>
    <field name="interval_type">months</field>
    <field name="numbercall">-1</field>
</record>

多公司模式

class CommissionPlan(models.Model):
    _name = 'commission.plan'

    company_id = fields.Many2one('res.company', required=True,
                                  default=lambda self: self.env.company)

    # Use sudo() carefully — only when crossing company boundaries is intended
    def get_global_plans(self):
        return self.sudo().search([('global_plan', '=', True)])

可重用逻辑的混合模式

class CommissionMixin(models.AbstractModel):
    _name = 'commission.mixin'
    _description = 'Adds commission tracking to any model'

    commission_ids = fields.One2many('sale.commission', 'res_id')
    commission_total = fields.Monetary(compute='_compute_commission_total', store=True)

    @api.depends('commission_ids.amount')
    def _compute_commission_total(self):
        for record in self:
            record.commission_total = sum(record.commission_ids.mapped('amount'))

# Apply to any model via class inheritance
class SaleOrder(models.Model):
    _inherit = ['sale.order', 'commission.mixin']

真实示例：完整佣金模块

有关完整的、可投入生产的委托模块示例，请访问 ECOSIRE 的开源 Odoo 模块，我们在其中遵循本指南中涵盖的所有最佳实践发布连接器、实用程序和业务模块。

我们的 Odoo 开发团队 使用这些确切的模式构建了 60 多个 Odoo 模块。如果您需要定制 Odoo Python 开发——从单个字段添加到完整的 ERP 实施——联系我们的团队 进行免费咨询。

常见问题

Odoo 18 需要什么 Python 版本？

Odoo 18 需要 Python 3.10 或更高版本，推荐使用 Python 3.12 版本。 Odoo 17 支持 Python 3.10+。请务必检查官方requirements.txt，了解您的Odoo 版本所需的确切依赖项。

如何调试 Odoo ORM 查询？

通过在 odoo.conf 文件中将 log_level 设置为 debug_sql 来启用 SQL 日志记录，或在命令行上传递 --log-sql。您还可以使用 self.env.cr.sql_log 来跟踪代码中的查询。对于性能分析，请使用 odoo.tools.profiler 中的内置 @profile 装饰器。

我应该使用 _inherit 还是 _inherits 来扩展模型？

95% 的情况下使用 _inherit（类继承）——它将字段和方法添加到现有模型的表中。仅当您需要一个单独的模型来透明地访问另一个模型的字段时才使用 _inherits（委托），例如创建继承所有 hr.employee 字段的专用员工类型。

如何处理多公司数据隔离？

将 company_id Many2one 字段添加到您的模型中，并使用返回 self.env.company 的默认 lambda。然后使用域 [('company_id', 'in', company_ids)] 创建一个全局 ir.rule。这可确保用户只能看到他们有权访问的公司的记录，这是标准的 Odoo 多公司模式。

@api.depends 和 @api.onchange 有什么区别？

@api.depends 在数据库中指定字段发生更改时触发，并用于存储的计算字段 - 它适用于 UI 和编程更改。 @api.onchange 仅在用户修改字段时在 UI 中触发，并用于设置默认值或显示警告。使用 @api.depends 实现数据完整性，使用 @api.onchange 实现用户体验改进。

如何有效地测试我的 Odoo 模块？

使用 TransactionCase 进行单元测试来测试业务逻辑 - 每个测试都在回滚的事务中运行。使用 HttpCase 测试控制器和网络游览。使用 @tagged('post_install', '-at_install') 标记测试以在模块安装后运行。目标是业务逻辑方法的代码覆盖率至少达到 80%。

后续步骤

构建生产级 Odoo 模块需要技术技能和领域专业知识。从简单的类继承开始，然后逐步发展到完整的自定义模块。进一步阅读：

• Odoo 自定义模块开发指南 — 模块开发的高级概述
• Odoo REST API 教程 — 与 Odoo 的外部集成
• 2026 年最佳 ERP 软件 — 了解 Odoo 在市场中的地位

需要专业的 Odoo 开发人员吗？ ECOSIRE 的 Odoo 开发团队 已为 40 个国家/地区的企业提供 200 多个自定义模块。从佣金引擎到完整的市场集成，我们的团队按照本指南中的每种模式编写生产就绪的代码。 获得免费咨询。