【三】DRF序列化进阶

序列化器的定义与使用

多表关联序列化

【1】准备工作

# settings.py
DATABASES = {
    'default': {
        # 数据库引擎选择使用MySQL
        'ENGINE': 'django.db.backends.mysql',
        # 指定数据库名字，需提前创建
        'NAME': 'books',
        # 指定数据库用户名
        'USER': 'root',
        # 指定数据库用户密码
        'PASSWORD': '123123',
        # 指定数据库连接IP
        'HOST': '127.0.0.1',
        # 指定数据库端口
        'PORT': 3306,
        # 指定数据库默认编码集(可选)
        'CHARSET': 'utf8mb4',

    }
}

【2】定制返回格式之source

# models.py
from django.db import models

class Book(models.Model):
    name = models.CharField(max_length=64)
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField()

    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.title


class Publish(models.Model):
    name = models.CharField(max_length=32,)
    addr = models.CharField(max_length=64)
    # 该字段不是给models看的，而是给校验行组件使用的
    email = models.EmailField()

    def __str__(self):
        return self.name


class Author(models.Model):
    name = models.CharField(max_length=32,null=True)
    age = models.IntegerField()

    def __str__(self):
        return self.name
  • 创建一个序列化serial.py文件
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

def data_name(name):
    if name.startswith('shi'):
        raise ValidationError('不能用shi开头')
    else:
        return name

class TaskSerializer(serializers.Serializer):
    # required=False表明该字段在反序列化时必须输入，默认True
    # allow_null	表明该字段是否允许传入None，默认False
    # default	    反序列化时使用的默认值
    task_name = serializers.CharField(required=False,allow_null=True,default='默认字段',validators=[data_name])
    task_id = serializers.CharField(max_length=64,validators=[data_name])
    task_time = serializers.DateTimeField()


class BookSerializer(serializers.Serializer):
    #  source 定制返回字段名，跟name必须对应
    book_name = serializers.CharField(source='name')
    # 显示出版社名字-->字符串类型--》CharField  可以跨表查询
    book_publish = serializers.CharField(source='publish.name')
    # 所有字段都可以被转成CharField
    publish_id = serializers.IntegerField(source='publish.id')

    title = serializers.CharField()
    price = serializers.IntegerField()
    publish = serializers.CharField()
  • book_name: 这是书籍的名称字段，source='name' 表示它会从模型中的 name 字段获取数据。
  • book_publish: 这是书籍的出版社名称字段，source='publish.name' 表示它会从关联的出版社模型中的 name 字段获取数据。
  • publish_id: 这是书籍的出版社ID字段，source='publish.id' 表示它会从关联的出版社模型中的 id 字段获取数据。
  • title: 这是书籍的标题字段，直接从模型中的 title 字段获取数据。
  • price: 这是书籍的价格字段，直接从模型中的 price 字段获取数据。
  • publish: 这是书籍的出版社字段。然而，在代码中没有指定 source，这意味着它将尝试从模型中的 publish 字段获取数据。但是，publish 字段是一个 ForeignKey 字段，它应该是一个模型实例，而不是字符串，因此这里会出现问题。
# views.py
from rest_framework.views import APIView
from Api02.models import Book,Task2
from Api02.serial import BookSerializer
from rest_framework.response import Response

class BookView(APIView):
    # 查询所有图书
    def get(self,request):
        print(request.data)
        # {'name': '去死', 'price': '222', 'publish': '人民日报'}
        res_list = Book.objects.all()
        print(res_list)
        # <QuerySet [<Book: 剑气长城>, <Book: 低头不见脚趾>, <Book: 恐怖如斯>, <Book: 大师>]>
        serializer = BookSerializer(instance=res_list,many=True)
        return Response(serializer.data)

image-20240413203820031

【3】定制返回字段模型类中书写方法

  • {name:书名,price:价格,publish:{name:出版社名,addr:地址},authors:[{},{}]}

返回详细信息

  • 先在models.py要实现表中添加
  • def publish_detail(self)这个函数跟我定义的serial.py中的字段要一致publish_detail。
class Book(models.Model):
    name = models.CharField(max_length=64)
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField()

    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name

    # 出版社对象
    @property
    def publish_detail(self):
        return {'name':self.publish.name,'addr':self.publish.addr}


    def authors_detail(self):
        list = []
        for author in self.authors.all():
            list.append({"name":author.name,'age':author.age})
        return list


# serial.py
class BookSerializer(serializers.Serializer):

    name = serializers.CharField()

    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()

    # publish = serializers.CharField() # 如果这样写，会把publish对象，打印的样子返回给前端
    # def __str__(self):
    #     return self.name    你要在表中的publish写下这个
    # 出版社对象
    publish_detail = serializers.DictField()

    # 所有作者
    authors_detail = serializers.ListField()

image-20240413211150599

之前的更改名字也一样

就是serial.py里面的表的字段跟models.py文件中的函数一样就行def book_name(self):

class BookSerializer(serializers.Serializer):

    book_name = serializers.CharField()

class Book(models.Model):
    name = models.CharField(max_length=64)
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField()

    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name
    
    #   def book_name(self):
    #    return self.name + 'xxxxxxx'

image-20240413214310992

【4】通过SerializerMethodField定制字段

  • serial.py

from rest_framework import serializers
from rest_framework.exceptions import ValidationError
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    title = serializers.SerializerMethodField()

    def get_title(self, res):
        return res.title + '云开月明！！'

    price = serializers.IntegerField()
    publish_date = serializers.DateField()

    # publish = serializers.CharField() # 如果这样写，会把publish对象，打印的样子返回给前端
    # def __str__(self):
    #     return self.name    你要在表中的publish写下这个
    # 出版社对象
    publish_detail = serializers.SerializerMethodField()

    def get_publish_detail(self, res):
        # res(任何obj、bai) 就是当前序列化到的book对象
        return {'name': res.publish.name, 'addr': res.publish.addr, 'id': res.pk}

    # 作者对象
    authors_detail = serializers.SerializerMethodField()

    def get_authors_detail(self, obj):
        data_list = []
        for i in obj.authors.all():
            data_list.append({'name': i.name, 'age': i.age, 'id': i.id})

        return data_list

image-20240413221140392

image-20240413220921587

Distributor经销商跟CarModel表车型是多对多关系
class DistributorSerializer(serializers.ModelSerializer):
    car_models = serializers.SlugRelatedField(
        '''
many=True 表示这是一个多对多关系，即一个经销商可能销售多个车型。
read_only=True 表示该字段是只读的，不能用于创建或更新对象。
slug_field='name' 指定了作为标识的字段名，在这里是 CarModel 表中的 name 字段。这意味着在序列化时，将使用 CarModel 对象的 name 字段来表示关联的车型。
        '''
        many=True,
        read_only=True,
        slug_field='name'
    )

    class Meta:
        model = Distributor
        fields = '__all__'

image-20240424095356579

# models.py
# 车厂
class CarFactory(models.Model):
    name = models.CharField(max_length=100)
    address = models.CharField(max_length=200)
    phone = models.CharField(max_length=20)

    def __str__(self):
        return self.name

# 车型
class CarModel(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    # 一对多
    factory = models.ForeignKey(CarFactory, on_delete=models.CASCADE, related_name='models')

    def __str__(self):
        return self.name
    
# serilaer.py    
# 一对多关系
class CarFactorySerializer(serializers.ModelSerializer):
    models = serializers.SerializerMethodField()

    def get_models(self, obj):
        # 获取与当前车厂相关联的所有车型
        models = obj.models.all()
        # 序列化车型数据
        serializer = CarModelSerializer(models, many=True)
        return serializer.data

    class Meta:
        model = CarFactory
        fields = ('id', 'name', 'address', 'phone', 'models')

    def get_models(self, obj):
        # 获取与当前车厂相关联的所有车型
        car_models = obj.models.all()
        # 序列化车型数据
        serialized_models = []
        for car_model in car_models:
            serialized_model = {
                'name': car_model.name,
                'price': car_model.price,
                'id': car_model.pk,
                'factory': obj.pk  # 车厂的主键作为车型的工厂信息
            }
            serialized_models.append(serialized_model)
        return serialized_models

    class Meta:
        model = CarFactory
        fields = ('id', 'name', 'address', 'phone', 'models')

image-20240424100439927

image-20240424101250833

多表关联反序列化

【5】定制返回之子序列化

​ 这个的重点就是要定义一个字序列化的类PublishSerializer里面的字段名是要表中的有的字段名（列名）

当使用子序列化器时，有几个要注意的重点：

  1. 字段名和源字段的匹配： 确保在子序列化器中使用的 source 参数与模型中的字段名匹配。这样才能正确地将父对象的属性传递给子序列化器进行序列化。
  2. 多对多关系处理： 如果处理的是多对多关系，确保在子序列化器中设置 many=True 参数，以表示这是一个多个对象的集合。
  3. 数据验证： 子序列化器也可以执行数据验证。确保在子序列化器中定义了适当的验证规则，以确保父对象和子对象的数据都被正确验证。
# 子序列化

class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    addr = serializers.CharField()
    email = serializers.EmailField()


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()

class BookSerializer(serializers.Serializer):

    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()

    # 如果这样写，会把publish对象，打印的样子返回给前端
    # publish = PublishSerializer()
    # 修改字段的名字"publish_res"
    # 一对多关系
    publish_res = PublishSerializer(source='publish')
	# # 修改字段的名字"authors_list"
    # 多对多关系
    authors_list = AuthorSerializer(source='authors',many=True)

image-20240413223603552

【6】反序化的保存

【1】删除

  • views.py

class BookDetailView(APIView):
    def delete(self, request, pk):
        instance = Book.objects.filter(pk=pk).first()
        if not instance:
            return Response({'code': 404, 'msg': 'Book not found'}, status=status.HTTP_404_NOT_FOUND)

        instance.delete()
        return Response({'code': 200, 'msg': 'Book deleted successfully'}, status=status.HTTP_200_OK)

  • urls.py

​ 在路由配置中，path('books/<int:pk>/', BookDetailView.as_view()) 表示处理单个书籍的操作，包括查找、更改和删除。而 path('books/', BookView.as_view()) 则表示处理多个书籍的操作，包括查找全部和添加。

from django.urls import path
# BookView、BookDetailView 这个就是我在views.py 定义的类
from Api02.views import BookView,BookDetailView  #

urlpatterns = [
    path('books/', BookView.as_view()),
    path('books/<int:pk>/', BookDetailView.as_view()),

]

  • 序列化组

第一种方法

class PublishSerializer(serializers.ModelSerializer):
    # id = serializers.IntegerField()
    # name = serializers.CharField()
    # addr = serializers.CharField()
    # email = serializers.EmailField()
    class Meta:
        model = Publish
        fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    # id = serializers.IntegerField()
    # name = serializers.CharField()
    # age = serializers.IntegerField()
    class Meta:
        model = Author
        fields = ['id', 'name', 'age']

class BookSerializer(serializers.ModelSerializer):

    # 如果这样写，会把publish对象，打印的样子返回给前端
    # publish = PublishSerializer()
    # 修改字段的名字"publish_res"
    publish_res = PublishSerializer(source='publish')


    authors_l = AuthorSerializer(source='authors', many=True)


    class Meta:
        model = Book
        fields = ['id','name', 'title', 'price', 'publish_date', 'publish_res', 'authors_l', 'delete']

第二种方法

class PublishSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    addr = serializers.CharField()
    email = serializers.EmailField()
    # class Meta:
    #     model = Publish
    #     fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()
    # class Meta:
    #     model = Author
    #     fields = ['id', 'name', 'age']

class BookSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()
    # 如果这样写，会把publish对象，打印的样子返回给前端
    # publish = PublishSerializer()
    # 修改字段的名字"publish_res"
    publish_res = PublishSerializer(source='publish')


    authors_l = AuthorSerializer(source='authors', many=True)


    class Meta:
        model = Book
        fields = ['id','name', 'title', 'price', 'publish_date', 'publish_res', 'authors_l', 'delete']

image-20240414192226872

image-20240414192250051

【2】更新

  • views.py

class BookDetailView(APIView):
    def put(self, request, pk):
        # instance 就是序列化的  res_data就是反序列化的
        pk = Book.objects.filter(pk=pk).first()
        print(pk)
        res_data = BookSerializer(data=request.data, instance=pk)
        if res_data.is_valid():
            # 验证过后的数据
            print(res_data.validated_data)
            # 保存数据
            res_data.save()
            return Response({'code': 200, "msg": res_data.data})
        else:
            return Response({'code': 404, 'msg': res_data.errors})

  • urls.py

这个两个路由跟上述一样

from django.urls import path
# BookView、BookDetailView 这个就是我在views.py 定义的类
from Api02.views import BookView,BookDetailView  #

urlpatterns = [
    path('books/', BookView.as_view()),
    path('books/<int:pk>/', BookDetailView.as_view()),

]

  • 序列化组

ModelSerializer使用

​ ModelSerializer 是 Django REST Framework 提供的一个便捷的序列化器类，用于简化与数据库模型的交互。它可以自动根据模型字段生成对应的序列化字段，并提供默认的序列化和反序列化逻辑。

​ 在序列化组中，你可以使用 ModelSerializer 来快速地将数据库模型转换为 JSON 格式的数据，或者将 JSON 格式的数据反序列化为模型对象。

# ModelSerializer使用


class PublishSerializer(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'age']

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'
        # fields=['id','name','publish_detail','authors_list']

        extra_kwargs = {
            'name': {'max_length': 8},  # 限制name不能超过8
            'publish': {'write_only': True},
            'authors': {'write_only': True},
        }

    # 自己再重写的字段
    # 这个字段用来做序列化
    publish_detail = PublishSerializer(source='publish',read_only=True)
    # 这个字段用来做序列化
    authors_list = AuthorSerializer(source='authors', many=True,read_only=True)

这样要注意如果没有加上子序列化这种方法

class PublishSerializer(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'age']
        
# views.py就必须在加上 pk = Book.objects.filter(pk=pk).first()否则就会报错
    def put(self, request, pk):
        pk = Book.objects.filter(pk=pk).first()
        print(pk)
        res_data = BookSerializer(data=request.data, instance=pk)
        if res_data.is_valid():
            # 验证过后的数据
            print(res_data.validated_data)
            # 保存数据
            res_data.save()
            return Response({'code': 200, "msg": res_data.data})
        else:
            return Response({'code': 404, 'msg': res_data.errors})

第二种

这里要注意在输入的时候ID这个就是必填字段了

class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()


    # 反序列化保持最要多表关联
    publish_save = serializers.IntegerField(source='publish',write_only=True)
    authors = serializers.ListField(write_only=True)
    # 更新
    def update(self, instance, validated_data):
        publish_id = validated_data.pop('publish')
        authors = validated_data.pop('authors')
        # 使用instance.pk获取主键值
        book_qs = Book.objects.filter(pk=instance.pk)
        # 使用update更新实例
        book_qs.update(**validated_data, publish_id=publish_id)
        # 获取更新后的实例
        instance = book_qs.first()

image-20240414194802347

image-20240414194850210

【3】添加

  • views.py

class BookView(APIView):
    def post(self, request):
        res_data = BookSerializer(data=request.data)
        print(res_data)
        if res_data.is_valid():
            # 验证过后的数据
            print(res_data.validated_data)
            # 保存数据
            res_data.save()
            return Response(res_data.data, status=status.HTTP_201_CREATED)
        else:
            return Response({'code': 404, 'msg': res_data.errors})

  • 序列化组

# 反序列化的保存
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()


    # 反序列化保持最要多表关联
    publish_save = serializers.IntegerField(source='publish',write_only=True)
    authors = serializers.ListField(write_only=True)
#
#     # 添加
    def create(self, validated_data):
        publish_id = validated_data.pop('publish')
        authors = validated_data.pop('authors')
        book = Book.objects.create(**validated_data, publish_id=publish_id)
        book.authors.add(*authors)
        return book

!在这里插入图片描述

image-20240414195306665

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/604311.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Redis 主从复制 初步认识

Redis 主从复制 初步认识

文章目录 定义拓扑拓扑定义单从拓扑多从拓扑树型拓扑 使用原理建立流程持续复制 定义 Redis主从复制技术的主要满足的需求是①数据恢复②负载均衡 ①数据恢复的理解&#xff1a;将数据同步到多个Redis服务器中&#xff0c;其中一个节点数据损毁&#xff0c;可通过复制其他节点…
阅读更多...
FreeRTOS学习笔记-基于stm32（6）时间片调度实验

FreeRTOS学习笔记-基于stm32（6）时间片调度实验

1、什么是时间片调度 在任务优先级相同的时候&#xff0c;CPU会轮流使用相同的时间去执行它&#xff0c;即时间片调度。这个相同的时间就是时间片。而时间片的大小就是SysTick的中断周期&#xff08;SysTick的中断周期可以修改&#xff09;。 比如有三个相同优先级的任务在运行…
阅读更多...
一张贴纸50万，炒房炒币的怎么都来炒CSGO皮肤了

一张贴纸50万，炒房炒币的怎么都来炒CSGO皮肤了

一张贴纸50万&#xff0c;为什么炒房炒币的都来炒CSGO饰品了&#xff1f; 一张贴纸50万&#xff0c;炒房炒币的怎么都来炒CSGO皮肤了&#xff1f; 经常有人问我&#xff0c;天天看你们买卖装备&#xff0c;买卖皮肤&#xff0c;说到底这都是虚拟产品&#xff0c;看得见摸不着的…
阅读更多...
ue引擎游戏开发笔记（35）——为射击添加轨道，并显示落点

ue引擎游戏开发笔记（35）——为射击添加轨道，并显示落点

1.需求分析&#xff1a; 我们只添加了开枪特效&#xff0c;事实上并没有实际的效果产生例如弹痕&#xff0c;落点等等。所以逐步实现射击的完整化&#xff0c;先从实现落点开始。 2.操作实现&#xff1a; 1.思路&#xff1a;可以这样理解&#xff0c;每次射击的过程是一次由摄…
阅读更多...
二层交换机与防火墙连通上网实验

二层交换机与防火墙连通上网实验

防火墙是一种网络安全设备&#xff0c;用于监控和控制网络流量。它可以帮助防止未经授权的访问&#xff0c;保护网络免受攻击和恶意软件感染。防火墙可以根据预定义的规则过滤流量&#xff0c;例如允许或阻止特定IP地址或端口的流量。它也可以检测和阻止恶意软件、病毒和其他威…
阅读更多...
Ansible-playbook剧本

Ansible-playbook剧本

目录 一、Ansible playbook简介 2.1 playbook格式 2.2 playbook组成部分 二、playbook示例 2.1 yaml文件编写 2.2 运行playbook 2.3 定义、引用变量 2.4 指定远程主机sudo切换用户 2.5 when条件判断 2.6 迭代 三、总结 Ansible中使用playbook脚本的作用和好处 一、A…
阅读更多...
5月8日学习记录

5月8日学习记录

_[FBCTF2019]RCEService&#xff08;preg_match函数的绕过&#xff09; 涉及知识点&#xff1a;preg_match函数绕过&#xff0c;json的格式&#xff0c;正则回溯 打开环境&#xff0c;要求用json的格式输入 搜索学习一下json的语法规则 数组&#xff08;Array&#xff09;用方括…
阅读更多...
OpenMV 图像串口传输示例

OpenMV 图像串口传输示例

注意&#xff1a;本程序根据 OpenMV采集图片通过串口发送&#xff0c;PC接收并保存为图片 更改。 一、例程说明 这个例程主要实现了以下功能: 1. OpenMV 端采集图像:使用OpenMV开发板上的摄像头采集实时图像数据。 2. 通过串口传输图像数据:将采集到的图像数据打包成字节流,…
阅读更多...
智慧工地的5大系统是什么？SaaS化大型微服务架构（智慧工地云平台源码）可多端展示登录

智慧工地的5大系统是什么？SaaS化大型微服务架构（智慧工地云平台源码）可多端展示登录

智慧工地解决方案依托计算机技术、物联网、云计算、大数据、人工智能、VR&AR等技术相结合&#xff0c;为工程项目管理提供先进技术手段&#xff0c;构建工地现场智能监控和控制体系&#xff0c;弥补传统方法在监管中的缺陷&#xff0c;最终实现项目对人、机、料、法、环的全…
阅读更多...
外企接受大龄程序员吗？

外企接受大龄程序员吗？

本人知乎账号同公众号&#xff1a;老胡聊Java&#xff0c;欢迎留言并咨询 亲身体会外企经历所见所闻&#xff0c;外企能接受大龄程序员。 1 大概是10年的时候&#xff0c;进一家知名外企&#xff0c;和我一起进的一位manager&#xff0c;后来听下来&#xff0c;年龄35&#xf…
阅读更多...
html的标签

html的标签

基础标签 标签描述<h1>-<h6>定义标题&#xff0c;h1最大&#xff0c;h6最小<font>定义文本的字体&#xff0c;字体尺寸&#xff0c;字体颜色<b>定义粗体文本<i>定义斜体文本<u>定义文本下划线<center>定义文本居中<p>定义段落…
阅读更多...
俄罗斯国际消费类电子电器展ICEE：人潮如织，盛况空前

俄罗斯国际消费类电子电器展ICEE：人潮如织，盛况空前

近日&#xff0c;备受全球瞩目的俄罗斯国际消费类电子电器展ICEE在莫斯科盛大落幕。本次展会为期四天&#xff0c;真的攒足了眼球&#xff0c;不仅俄罗斯这边的很多媒体和自媒体有报道&#xff0c;展会第一天&#xff0c;很多参展商通过短视频平台将展会的盛况传到了国内&#…
阅读更多...
Ubuntu22.04下安装kafka_2.11-0.10.1.0并运行简单实例

Ubuntu22.04下安装kafka_2.11-0.10.1.0并运行简单实例

目录 一、版本信息 二、安装Kafka 1.将Kafka安装包移到下载目录中 2.下载Spark并确保hadoop用户对Spark目录有操作权限 三、启动Kafka并测试Kafka是否正常工作 1.启动Kafka 2.测试Kafka是否正常工作 一、版本信息 虚拟机产品&#xff1a;VMware Workstation 17 Pro 虚…
阅读更多...
AI PC，到底谁的梦想、谁的红利？

AI PC，到底谁的梦想、谁的红利？

世界上第一台通用计算机是1946年诞生的埃尼阿克&#xff0c;世界上第一台便携电脑是1981年诞生的“奥斯本1号”&#xff0c;世界上第一部智能手机是1993年诞生的IBM Simon。 它们之间看起来毫无关系&#xff0c;但却暗含一种关于创新的微妙潜规则——随着时间推移&#xff0c;…
阅读更多...
MM模块学习一（供应商创建，物料类型的定义及功能）

MM模块学习一（供应商创建，物料类型的定义及功能）

物料管理流程&#xff1a; 源头&#xff1a;采购需求->采购申请 MRP&#xff1a;物料需求计划。运行物料需求计划的结果&#xff0c;根据物料的性质来判断是外购&#xff08;采购申请&#xff09;或者是生产&#xff08;计划订单->生产订单&#xff09;。 采购申请&am…
阅读更多...
acwing算法提高之数据结构--平衡树Treap

acwing算法提高之数据结构--平衡树Treap

目录 1 介绍2 训练 1 介绍 本博客用来记录使用平衡树求解的题目。 插入、删除、查询操作的时间复杂度都是O(logN)。 动态维护一个有序序列。 2 训练 题目1&#xff1a;253普通平衡树 C代码如下&#xff0c; #include <cstdio> #include <cstring> #include …
阅读更多...
Postgresql源码（128）深入分析JIT中的函数内联llvm_inline

Postgresql源码（128）深入分析JIT中的函数内联llvm_inline

相关 《Postgresql源码&#xff08;127&#xff09;投影ExecProject的表达式执行分析》 《LLVM的ThinLTO编译优化技术在Postgresql中的应用》 《LLVM&#xff08;5&#xff09;ORC实例分析》 1 JIT优化效果 create table t1(i int primary key, j int, k int); insert into t1…
阅读更多...
嵌入式开发三：STM32初体验

嵌入式开发三：STM32初体验

本节主要向大家介绍如何开发过程中的基本操作&#xff0c;如编译、串口下载、仿真器下载、仿真调试程序&#xff0c;体验一下 STM32 的开发流程&#xff0c;并介绍 MDK5 的一些使用技巧&#xff0c;通过本节的学习&#xff0c;将对 STM32 的开发流程和 MDK5 使用有个大概了解&a…
阅读更多...
Windows安全加固-账号与口令管理

Windows安全加固-账号与口令管理

在当今日益增长的网络安全威胁中&#xff0c;Windows系统的安全加固显得尤为重要。其中&#xff0c;账号与口令管理作为系统安全的第一道防线&#xff0c;其重要性不言而喻。本文将深入探讨Windows安全加固中的账号与口令管理策略&#xff0c;以确保系统的安全性和稳定性。 账…
阅读更多...
认识大模型提示词

认识大模型提示词

一、写作助理 &#x1f4a5;最常使用的 prompt&#xff0c;用于优化文本的语法、清晰度和简洁度&#xff0c;提高可读性。 输入&#xff1a;作为一名写作改进助理&#xff0c;你的任务是改进所提供文本的拼写、语法、清晰、简洁和整体可读性&#xff0c;同时分解长句&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站