你所知的业务操作分类

不画画的卡布
2 阅读6分钟

Python 业务操作分类指南

1. 数据查询类操作

1.1 基本查询

# 查询单个对象
def get_user_by_id(user_id):
    """根据ID获取用户"""
    user = User.objects.get(id=user_id)  # Django示例
    return user

# 查询列表
def get_active_users():
    """获取所有活跃用户"""
    users = User.objects.filter(is_active=True)
    return list(users)

# 条件查询
def get_users_by_conditions(name=None, age_gt=None):
    """多条件查询用户"""
    query = User.objects.all()
    if name:
        query = query.filter(name__contains=name)
    if age_gt:
        query = query.filter(age__gt=age_gt)
    return query

1.2 关联查询

def get_user_with_orders(user_id):
    """查询用户及其所有订单（关联查询）"""
    # 使用select_related（一对一，多对一）
    user = User.objects.select_related('profile').get(id=user_id)
    
    # 使用prefetch_related（一对多，多对多）
    user = User.objects.prefetch_related('orders').get(id=user_id)
    return user

1.3 聚合统计

from django.db.models import Count, Sum, Avg

def get_user_statistics():
    """用户数据统计"""
    stats = {
        'total_users': User.objects.count(),
        'active_users': User.objects.filter(is_active=True).count(),
        'avg_age': User.objects.aggregate(Avg('age'))['age__avg'],
        'users_by_city': User.objects.values('city').annotate(count=Count('id'))
    }
    return stats

2. 数据创建类操作

2.1 单条创建

def create_user(user_data):
    """创建新用户"""
    try:
        user = User.objects.create(
            username=user_data['username'],
            email=user_data['email'],
            age=user_data.get('age', 18)  # 默认值
        )
        return {'success': True, 'user': user}
    except Exception as e:
        return {'success': False, 'error': str(e)}

2.2 批量创建

def create_users_bulk(users_data):
    """批量创建用户（性能优化）"""
    users = [
        User(
            username=data['username'],
            email=data['email']
        )
        for data in users_data
    ]
    created_users = User.objects.bulk_create(users)
    return created_users

2.3 复杂对象创建

def create_order_with_items(order_data, items_data):
    """创建订单及相关商品（事务操作）"""
    from django.db import transaction
    
    with transaction.atomic():  # 保证原子性
        # 创建订单
        order = Order.objects.create(
            user_id=order_data['user_id'],
            total_amount=order_data['total_amount']
        )
        
        # 创建订单项
        order_items = []
        for item in items_data:
            order_items.append(OrderItem(
                order=order,
                product_id=item['product_id'],
                quantity=item['quantity']
            ))
        OrderItem.objects.bulk_create(order_items)
    
    return order

3. 数据更新类操作

3.1 单字段更新

def update_user_name(user_id, new_name):
    """更新用户名称"""
    try:
        user = User.objects.get(id=user_id)
        user.name = new_name
        user.save(update_fields=['name'])  # 只更新指定字段
        return {'success': True, 'message': '更新成功'}
    except User.DoesNotExist:
        return {'success': False, 'error': '用户不存在'}

3.2 批量更新

def update_user_status(user_ids, is_active):
    """批量更新用户状态"""
    updated_count = User.objects.filter(id__in=user_ids).update(
        is_active=is_active,
        updated_at=timezone.now()  # 更新时间戳
    )
    return updated_count

3.3 条件更新

def increment_user_score(user_id, points):
    """增加用户积分（原子操作）"""
    from django.db.models import F
    
    updated = User.objects.filter(id=user_id).update(
        score=F('score') + points  # 使用F表达式避免竞态条件
    )
    return updated > 0

4. 数据删除类操作

4.1 单条删除

def delete_user(user_id):
    """删除用户（逻辑删除）"""
    try:
        user = User.objects.get(id=user_id)
        user.is_deleted = True  # 逻辑删除标记
        user.deleted_at = timezone.now()
        user.save()
        return {'success': True, 'message': '删除成功'}
    except User.DoesNotExist:
        return {'success': False, 'error': '用户不存在'}

4.2 批量删除

def delete_inactive_users():
    """批量删除长时间不活跃的用户"""
    from datetime import timedelta
    from django.utils import timezone
    
    cutoff_date = timezone.now() - timedelta(days=365)
    
    # 物理删除
    deleted_count, _ = User.objects.filter(
        is_active=False,
        last_login__lt=cutoff_date
    ).delete()
    
    return deleted_count

5. 业务验证类操作

5.1 数据验证

def validate_user_data(user_data):
    """验证用户数据"""
    errors = []
    
    # 必填字段验证
    required_fields = ['username', 'email']
    for field in required_fields:
        if not user_data.get(field):
            errors.append(f'{field}是必填字段')
    
    # 邮箱格式验证
    email = user_data.get('email')
    if email and '@' not in email:
        errors.append('邮箱格式不正确')
    
    # 年龄范围验证
    age = user_data.get('age')
    if age and (age < 0 or age > 150):
        errors.append('年龄必须在0-150之间')
    
    return {'is_valid': len(errors) == 0, 'errors': errors}

5.2 权限验证

def check_permission(user_id, resource, action):
    """检查用户权限"""
    from django.contrib.auth.decorators import permission_required
    
    # 基于角色的权限检查
    user = User.objects.get(id=user_id)
    
    # 检查用户角色
    if not user.role:
        return False
    
    # 检查具体权限
    permissions = {
        'admin': ['read', 'write', 'delete'],
        'user': ['read'],
        'guest': []
    }
    
    return action in permissions.get(user.role, [])

6. 接口调用类操作

6.1 HTTP API调用

import requests
import json

def call_external_api(url, method='GET', data=None, headers=None):
    """调用外部API"""
    default_headers = {
        'Content-Type': 'application/json',
        'User-Agent': 'MyApp/1.0'
    }
    
    if headers:
        default_headers.update(headers)
    
    try:
        if method.upper() == 'GET':
            response = requests.get(url, headers=default_headers, params=data)
        elif method.upper() == 'POST':
            response = requests.post(url, headers=default_headers, json=data)
        elif method.upper() == 'PUT':
            response = requests.put(url, headers=default_headers, json=data)
        else:
            return {'success': False, 'error': '不支持的HTTP方法'}
        
        response.raise_for_status()  # 检查HTTP错误
        return {'success': True, 'data': response.json()}
        
    except requests.RequestException as e:
        return {'success': False, 'error': str(e)}

6.2 API参数构建

def build_api_params(base_params, dynamic_params):
    """构建API请求参数"""
    params = base_params.copy()
    
    # 添加动态参数
    for key, value in dynamic_params.items():
        if value is not None:  # 跳过None值
            params[key] = value
    
    # 处理特殊格式
    if 'date_range' in params:
        params['start_date'] = params['date_range'][0]
        params['end_date'] = params['date_range'][1]
        del params['date_range']
    
    return params

7. 数据处理类操作

7.1 数据转换

def transform_user_data(users):
    """转换用户数据格式"""
    result = []
    for user in users:
        transformed = {
            'id': user.id,
            'name': user.username,
            'contact': {
                'email': user.email,
                'phone': user.phone
            },
            'meta': {
                'created_at': user.date_joined.strftime('%Y-%m-%d'),
                'is_active': user.is_active
            }
        }
        result.append(transformed)
    return result

7.2 数据清洗

def clean_user_data(raw_data):
    """清洗用户数据"""
    cleaned_data = {}
    
    # 去除空格
    for key, value in raw_data.items():
        if isinstance(value, str):
            cleaned_data[key] = value.strip()
        else:
            cleaned_data[key] = value
    
    # 转换类型
    if 'age' in cleaned_data:
        try:
            cleaned_data['age'] = int(cleaned_data['age'])
        except (ValueError, TypeError):
            cleaned_data['age'] = None
    
    # 移除空值
    cleaned_data = {k: v for k, v in cleaned_data.items() 
                   if v not in [None, '']}
    
    return cleaned_data

8. 文件操作类

8.1 文件上传处理

def handle_file_upload(uploaded_file, user_id):
    """处理文件上传"""
    import os
    from django.core.files.storage import FileSystemStorage
    
    # 文件验证
    allowed_extensions = ['.jpg', '.png', '.pdf']
    file_ext = os.path.splitext(uploaded_file.name)[1].lower()
    
    if file_ext not in allowed_extensions:
        return {'success': False, 'error': '不支持的文件格式'}
    
    # 文件大小限制（5MB）
    if uploaded_file.size > 5 * 1024 * 1024:
        return {'success': False, 'error': '文件大小不能超过5MB'}
    
    # 保存文件
    fs = FileSystemStorage()
    filename = f"user_{user_id}_{uploaded_file.name}"
    saved_path = fs.save(filename, uploaded_file)
    
    return {'success': True, 'path': saved_path}

9. 缓存操作类

9.1 缓存读写

from django.core.cache import cache

def get_or_set_cache(key, func, timeout=300):
    """获取或设置缓存（缓存穿透保护）"""
    # 尝试从缓存获取
    data = cache.get(key)
    
    if data is not None:
        return data
    
    # 缓存未命中，执行函数获取数据
    data = func()
    
    # 设置缓存
    if data is not None:
        cache.set(key, data, timeout)
    
    return data

10. 事务与锁操作

10.1 数据库事务

from django.db import transaction

@transaction.atomic
def transfer_money(from_account_id, to_account_id, amount):
    """转账操作（事务保证一致性）"""
    from_account = Account.objects.select_for_update().get(id=from_account_id)
    to_account = Account.objects.select_for_update().get(id=to_account_id)
    
    # 检查余额
    if from_account.balance < amount:
        raise ValueError("余额不足")
    
    # 执行转账
    from_account.balance -= amount
    to_account.balance += amount
    
    from_account.save()
    to_account.save()
    
    # 记录交易
    Transaction.objects.create(
        from_account=from_account,
        to_account=to_account,
        amount=amount
    )
    
    return True

业务操作分类总结

类别典型操作常见方法/技术
查询类​获取数据、条件查询、关联查询get(), filter(), select_related(), prefetch_related()
创建类​新增数据、批量创建create(), bulk_create(), save()
更新类​修改字段、批量更新update(), save(), F表达式
删除类​软删除、硬删除delete(), 逻辑删除标记
验证类​数据验证、权限检查表单验证、权限装饰器
接口类​API调用、参数处理requests库、API封装
处理类​数据转换、清洗字典操作、类型转换
文件类​上传下载、文件处理文件存储、格式验证
缓存类​缓存读写、一致性cache.set(), cache.get()
事务类​原子操作、并发控制transaction.atomic, select_for_update()

最佳实践建议

  1. 单一职责：每个函数只做一件事
  2. 错误处理：使用try-except捕获预期异常
  3. 日志记录：关键操作添加日志
  4. 参数验证：入口处验证所有输入
  5. 性能考虑：批量操作优先于循环操作
  6. 事务边界：相关操作放在同一事务中
  7. 缓存策略：合理使用缓存提高性能
  8. 代码复用：提取公共方法避免重复代码
avatar
文章
阅读
粉丝