美多商城项目：结算订单与提交订单

于 2022-12-06 11:31:38 发布
阅读量864 收藏 1
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itcast_cn/article/details/128199716
版权

一、结算订单

 

1. 结算订单逻辑分析

结算订单是从Redis购物车中查询出被勾选的商品信息进行结算并展示。

2. 结算订单接口设计和定义

1.请求方式

选项方案
请求方法GET
请求地址/orders/settlement/

3. 结算订单后端逻辑实现

class OrderSettlementView(LoginRequiredMixin, View):
    """结算订单"""

    def get(self, request):
        """提供订单结算页面"""
        # 获取登录用户
        user = request.user

        # 查询当前用户的所有地址信息
        addresses = Address.objects.filter(user=request.user, 
                                               is_deleted=False)

        # 从Redis购物车中查询出被勾选的商品信息
        redis_conn = get_redis_connection('carts')
        redis_cart = redis_conn.hgetall('carts_%s' % user.id)
        cart_selected = redis_conn.smembers('selected_%s' % user.id)
        cart = {}
        for sku_id in cart_selected:
            cart[int(sku_id)] = int(redis_cart[sku_id])

        # 查询商品信息
        sku_list = []
        # 查询商品信息
        skus = SKU.objects.filter(id__in=cart.keys())
        for sku in skus:
            sku_list.append({
                'id':sku.id,
                'name':sku.name,
                'default_image_url':sku.default_image.url,
                'count': cart[sku.id],
                'price':sku.price
            })

        # 补充运费
        freight = Decimal('10.00')

        addresses_list = []
        for address in addresses:
            addresses_list.append({
                'id':address.id,
                'province':address.province.name,
                'city':address.city.name,
                'district':address.district.name,
                'place':address.place,
                'receiver':address.receiver,
                'mobile':address.mobile
            })

        # 渲染界面
        context = {
            'addresses': addresses_list,
            'skus': sku_list,
            'freight': freight,
        }

        return http.JsonResponse({'code':0,
                                  'errmsg':'ok',
                                  'context':context})

二、提交订单 

2.1 创建订单数据库表

生成的订单数据要做持久化处理，而且需要在《我的订单》页面展示出来。

1. 订单数据库表分析

注意：

  • 订单号不再采用数据库自增主键，而是由后端生成。
  • 一个订单中可以有多个商品信息，订单基本信息和订单商品信息是一对多的关系。

 

 2. 订单模型类迁移建表

from django.db import models
from apps.goods.models import SKU
from apps.users.models import User, Address
from utils.models import BaseModel


class OrderInfo(BaseModel):
    """订单信息"""
    PAY_METHODS_ENUM = {
        "CASH": 1,
        "ALIPAY": 2
    }
    PAY_METHOD_CHOICES = (
        (1, "货到付款"),
        (2, "支付宝"),
    )
    ORDER_STATUS_ENUM = {
        "UNPAID": 1,
        "UNSEND": 2,
        "UNRECEIVED": 3,
        "UNCOMMENT": 4,
        "FINISHED": 5
    }
    ORDER_STATUS_CHOICES = (
        (1, "待支付"),
        (2, "待发货"),
        (3, "待收货"),
        (4, "待评价"),
        (5, "已完成"),
        (6, "已取消"),
    )
    order_id = models.CharField(max_length=64, primary_key=True, verbose_name="订单号")
    user = models.ForeignKey(User, on_delete=models.PROTECT, verbose_name="下单用户")
    address = models.ForeignKey(Address, on_delete=models.PROTECT, verbose_name="收货地址")
    total_count = models.IntegerField(default=1, verbose_name="商品总数")
    total_amount = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="商品总金额")
    freight = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="运费")
    pay_method = models.SmallIntegerField(choices=PAY_METHOD_CHOICES, default=1, verbose_name="支付方式")
    status = models.SmallIntegerField(choices=ORDER_STATUS_CHOICES, default=1, verbose_name="订单状态")

    class Meta:
        db_table = "tb_order_info"
        verbose_name = '订单基本信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.order_id


class OrderGoods(BaseModel):
    """订单商品"""
    SCORE_CHOICES = (
        (0, '0分'),
        (1, '20分'),
        (2, '40分'),
        (3, '60分'),
        (4, '80分'),
        (5, '100分'),
    )
    order = models.ForeignKey(OrderInfo, related_name='skus', on_delete=models.CASCADE, verbose_name="订单")
    sku = models.ForeignKey(SKU, on_delete=models.PROTECT, verbose_name="订单商品")
    count = models.IntegerField(default=1, verbose_name="数量")
    price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="单价")
    comment = models.TextField(default="", verbose_name="评价信息")
    score = models.SmallIntegerField(choices=SCORE_CHOICES, default=5, verbose_name='满意度评分')
    is_anonymous = models.BooleanField(default=False, verbose_name='是否匿名评价')
    is_commented = models.BooleanField(default=False, verbose_name='是否评价了')

    class Meta:
        db_table = "tb_order_goods"
        verbose_name = '订单商品'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.sku.name

2.1 保存订单基本信息和订单商品信息

1. 提交订单接口设计和定义

1.请求方式

选项方案
请求方法POST
请求地址/orders/commit/

2.请求参数：JSON

参数名类型是否必传说明
address_idint是用户地址编号
pay_methodint是用户支付方式

3.响应结果：JSON

字段说明
code状态码
errmsg错误信息
order_id订单编号

4.后端接口定义

class OrderCommitView(LoginRequiredJSONMixin, View):
    """订单提交"""

    def post(self, request):
        """保存订单信息和订单商品信息"""
        pass

提示：

  • 订单数据分为订单基本信息和订单商品信息，二者为一对多的关系。

  • 保存到订单的数据是从Redis购物车中的已勾选的商品信息。

2. 保存订单基本信息

class OrderCommitView(LoginRequiredJSONMixin, View):
    """提交订单"""

    def post(self, request):
        """保存订单信息和订单商品信息"""
        # 获取当前要保存的订单数据
        json_dict = json.loads(request.body.decode())
        address_id = json_dict.get('address_id')
        pay_method = json_dict.get('pay_method')
        # 校验参数
        if not all([address_id, pay_method]):
            return http.HttpResponseBadRequest('缺少必传参数')
        # 判断address_id是否合法
        try:
            address = Address.objects.get(id=address_id)
        except Exception:
            return http.HttpResponseBadRequest('参数address_id错误')
        # 判断pay_method是否合法
        if pay_method not in [OrderInfo.PAY_METHODS_ENUM['CASH'], OrderInfo.PAY_METHODS_ENUM['ALIPAY']]:
            return http.HttpResponseBadRequest('参数pay_method错误')

        # 获取登录用户
        user = request.user
        # 生成订单编号：年月日时分秒+用户编号
        order_id = timezone.localtime().strftime('%Y%m%d%H%M%S') + ('%09d' % user.id)
        # 保存订单基本信息 OrderInfo（一）
        order = OrderInfo.objects.create(
            order_id=order_id,
            user=user,
            address=address,
            total_count=0,
            total_amount=Decimal('0'),
            freight=Decimal('10.00'),
            pay_method=pay_method,
            status=OrderInfo.ORDER_STATUS_ENUM['UNPAID'] if pay_method == OrderInfo.PAY_METHODS_ENUM['ALIPAY'] else
            OrderInfo.ORDER_STATUS_ENUM['UNSEND']
        )
        pass

3. 保存订单商品信息

class OrderCommitView(LoginRequiredJSONMixin, View):
    """提交订单"""

    def post(self, request):
        """保存订单信息和订单商品信息"""
        # 获取当前保存订单时需要的信息
        ......

        # 保存订单基本信息 OrderInfo（一）
        ......

        # 从redis读取购物车中被勾选的商品信息
        redis_conn = get_redis_connection('carts')
        redis_cart = redis_conn.hgetall('carts_%s' % user.id)
        selected = redis_conn.smembers('selected_%s' % user.id)
        carts = {}
        for sku_id in selected:
            carts[int(sku_id)] = int(redis_cart[sku_id])
        sku_ids = carts.keys()

        # 遍历购物车中被勾选的商品信息
        for sku_id in sku_ids:
            # 查询SKU信息
            sku = SKU.objects.get(id=sku_id)
            # 判断SKU库存
            sku_count = carts[sku.id]
            if sku_count > sku.stock:
                return http.JsonResponse({'code': 400, 'errmsg': '库存不足'})

            # SKU减少库存，增加销量
            sku.stock -= sku_count
            sku.sales += sku_count
            sku.save()

            # 保存订单商品信息 OrderGoods（多）
            OrderGoods.objects.create(
                order=order,
                sku=sku,
                count=sku_count,
                price=sku.price,
            )

            # 保存商品订单中总价和总数量
            order.total_count += sku_count
            order.total_amount += (sku_count * sku.price)

        # 添加邮费和保存订单信息
        order.total_amount += order.freight
        order.save()

        # 清除购物车中已结算的商品
        pl = redis_conn.pipeline()
        pl.hdel('carts_%s' % user.id, *selected)
        pl.srem('selected_%s' % user.id, *selected)
        pl.execute()

        # 响应提交订单结果
        return http.JsonResponse({'code': 0, 'errmsg': '下单成功', 'order_id': order.order_id})

 2.3 使用事务保存订单数据

重要提示：

  • 在保存订单数据时，涉及到多张表（OrderInfo、OrderGoods、SKU、SPU）的数据修改，对这些数据的修改应该是一个整体事务，即要么一起成功，要么一起失败。
  • Django中对于数据库的事务，默认每执行一句数据库操作，便会自动提交。所以我们需要在保存订单中自己控制数据库事务的执行流程。

1. Django中事务的使用

1.Django中事务的使用方案

  • 在Django中可以通过django.db.transaction模块提供的atomic来定义一个事务。

atomic提供两种方案实现事务：

装饰器用法：

  • from django.db import transaction

@transaction.atomic
def viewfunc(request):
  # 这些代码会在一个事务中执行
  ......

with语句用法：

from django.db import transaction

def viewfunc(request):
  # 这部分代码不在事务中，会被Django自动提交
  ......

  with transaction.atomic():
      # 这部分代码会在事务中执行
      ......

2.事务方案的选择：

  • 装饰器用法： 整个视图中所有MySQL数据库的操作都看做一个事务，范围太大，不够灵活。而且无法直接作用于类视图。
  • with语句用法： 可以灵活的有选择性的把某些MySQL数据库的操作看做一个事务。而且不用关心视图的类型。
  • 综合考虑后我们选择 with语句实现事务

3.事务中的保存点：

  • 在Django中，还提供了保存点的支持，可以在事务中创建保存点来记录数据的特定状态，数据库出现错误时，可以回滚到数据保存点的状态。
from django.db import transaction

# 创建保存点
save_id = transaction.savepoint()  
# 回滚到保存点
transaction.savepoint_rollback(save_id)
# 提交从保存点到当前状态的所有数据库事务操作
transaction.savepoint_commit(save_id)

2. 使用事务保存订单数据

class OrderCommitView(LoginRequiredJSONMixin, View):
    """订单提交"""

    def post(self, request):
        """保存订单信息和订单商品信息"""
        # 获取当前保存订单时需要的信息
        ......

        # 显式的开启一个事务
        with transaction.atomic():
            # 创建事务保存点
            save_id = transaction.savepoint()

            # 暴力回滚
            try:
                # 保存订单基本信息 OrderInfo（一）
                order = OrderInfo.objects.create(
                    order_id=order_id,
                    user=user,
                    address=address,
                    total_count=0,
                    total_amount=Decimal('0'),
                    freight=Decimal('10.00'),
                    pay_method=pay_method,
                    status=OrderInfo.ORDER_STATUS_ENUM['UNPAID'] if pay_method == OrderInfo.PAY_METHODS_ENUM['ALIPAY'] else
                    OrderInfo.ORDER_STATUS_ENUM['UNSEND']
                )

                # 从redis读取购物车中被勾选的商品信息
                redis_conn = get_redis_connection('carts')
                redis_cart = redis_conn.hgetall('carts_%s' % user.id)
                selected = redis_conn.smembers('selected_%s' % user.id)
                carts = {}
                for sku_id in selected:
                    carts[int(sku_id)] = int(redis_cart[sku_id])
                sku_ids = carts.keys()

                # 遍历购物车中被勾选的商品信息
                for sku_id in sku_ids:
                    # 查询SKU信息
                    sku = SKU.objects.get(id=sku_id)
                    # 判断SKU库存
                    sku_count = carts[sku.id]
                    if sku_count > sku.stock:
                        # 出错就回滚
                        transaction.savepoint_rollback(save_id)
                        return http.JsonResponse({'code': 400, 'errmsg': '库存不足'})

                    # SKU减少库存，增加销量
                    sku.stock -= sku_count
                    sku.sales += sku_count
                    sku.save()

                    # 保存订单商品信息 OrderGoods（多）
                    OrderGoods.objects.create(
                        order=order,
                        sku=sku,
                        count=sku_count,
                        price=sku.price,
                    )

                    # 保存商品订单中总价和总数量
                    order.total_count += sku_count
                    order.total_amount += (sku_count * sku.price)

                # 添加邮费和保存订单信息
                order.total_amount += order.freight
                order.save()
            except Exception as e:
                logger.error(e)
                transaction.savepoint_rollback(save_id)
                return http.JsonResponse({'code': 400, 'errmsg': '下单失败'})

            # 提交订单成功，显式的提交一次事务
            transaction.savepoint_commit(save_id)

        # 清除购物车中已结算的商品
        pl = redis_conn.pipeline()
        pl.hdel('carts_%s' % user.id, *selected)
        pl.srem('selected_%s' % user.id, *selected)
        pl.execute()

        # 响应提交订单结果
        return http.JsonResponse({'code': 0, 'errmsg': '下单成功', 'order_id': order.order_id})

 2.4 使用乐观锁并发下单

重要提示：

  • 在多个用户同时发起对同一个商品的下单请求时，先查询商品库存，再修改商品库存，会出现资源竞争问题，导致库存的最终结果出现异常。

1. 并发下单问题演示和解决方案

 

解决办法：

  • 悲观锁

    • 当查询某条记录时，即让数据库为该记录加锁，锁住记录后别人无法操作，使用类似如下语法

      select stock from tb_sku where id=1 for update;

SKU.objects.select_for_update().get(id=1)

    • 悲观锁类似于我们在多线程资源竞争时添加的互斥锁，容易出现死锁现象，采用不多。

  • 乐观锁

    • 乐观锁并不是真实存在的锁，而是在更新的时候判断此时的库存是否是之前查询出的库存，如果相同，表示没人修改，可以更新库存，否则表示别人抢过资源，不再执行库存更新。类似如下操作

      update tb_sku set stock=2 where id=1 and stock=7;

SKU.objects.filter(id=1, stock=7).update(stock=2)

  • 任务队列

    • 将下单的逻辑放到任务队列中（如celery），将并行转为串行，所有人排队下单。比如开启只有一个进程的Celery，一个订单一个订单的处理。

2. 使用乐观锁并发下单

思考：

  • 下单成功的条件是什么？
    • 首先库存大于购买量，然后更新库存和销量时原始库存没变。

结论：

  • 所以在用户库存满足的情况下，如果更新库存和销量时原始库存有变，那么继续给用户下单的机会。
class OrderCommitView(LoginRequiredJSONMixin, View):
    """订单提交"""

    def post(self, request):
        """保存订单信息和订单商品信息"""
        # 获取当前保存订单时需要的信息
        ......

        # 显式的开启一个事务
        with transaction.atomic():
            # 创建事务保存点
            save_id = transaction.savepoint()

            # 暴力回滚
            try:
                # 保存订单基本信息 OrderInfo（一）
                order = OrderInfo.objects.create(
                    order_id=order_id,
                    user=user,
                    address=address,
                    total_count=0,
                    total_amount=Decimal('0'),
                    freight=Decimal('10.00'),
                    pay_method=pay_method,
                    status=OrderInfo.ORDER_STATUS_ENUM['UNPAID'] if pay_method == OrderInfo.PAY_METHODS_ENUM['ALIPAY'] else
                    OrderInfo.ORDER_STATUS_ENUM['UNSEND']
                )

                # 从redis读取购物车中被勾选的商品信息
                redis_conn = get_redis_connection('carts')
                redis_cart = redis_conn.hgetall('carts_%s' % user.id)
                selected = redis_conn.smembers('selected_%s' % user.id)
                carts = {}
                for sku_id in selected:
                    carts[int(sku_id)] = int(redis_cart[sku_id])
                sku_ids = carts.keys()

                # 遍历购物车中被勾选的商品信息
                for sku_id in sku_ids:
                    while True:
                        # 查询SKU信息
                        sku = SKU.objects.get(id=sku_id)

                        # 读取原始库存
                        origin_stock = sku.stock
                        origin_sales = sku.sales

                        # 判断SKU库存
                        sku_count = carts[sku.id]
                        if sku_count > origin_stock:
                            # 事务回滚
                            transaction.savepoint_rollback(save_id)
                            return http.JsonResponse({'code': 400, 'errmsg': '库存不足'})

                        # 模拟延迟
                        # import time
                        # time.sleep(5)

                        # SKU减少库存，增加销量
                        # sku.stock -= sku_count
                        # sku.sales += sku_count
                        # sku.save()

                        # 乐观锁更新库存和销量
                        new_stock = origin_stock - sku_count
                        new_sales = origin_sales + sku_count
                        result = SKU.objects.filter(id=sku_id, stock=origin_stock).update(stock=new_stock, sales=new_sales)
                        # 如果下单失败，但是库存足够时，继续下单，直到下单成功或者库存不足为止
                        if result == 0:
                            continue

                        # 保存订单商品信息 OrderGoods（多）
                        OrderGoods.objects.create(
                            order=order,
                            sku=sku,
                            count=sku_count,
                            price=sku.price,
                        )

                        # 保存商品订单中总价和总数量
                        order.total_count += sku_count
                        order.total_amount += (sku_count * sku.price)

                        # 下单成功或者失败就跳出循环
                        break

                # 添加邮费和保存订单信息
                order.total_amount += order.freight
                order.save()
            except Exception as e:
                logger.error(e)
                # 事务回滚
                transaction.savepoint_rollback(save_id)
                return http.JsonResponse({'code': 400, 'errmsg': '下单失败'})

        # 保存订单数据成功，显式的提交一次事务
        transaction.savepoint_commit(save_id)

        # 清除购物车中已结算的商品
        pl = redis_conn.pipeline()
        pl.hdel('carts_%s' % user.id, *selected)
        pl.srem('selected_%s' % user.id, *selected)
        pl.execute()

        # 响应提交订单结果
        return http.JsonResponse({'code': 0, 'errmsg': '下单成功', 'order_id': order.order_id})

3. MySQL事务隔离级别

  • 事务隔离级别指的是在处理同一个数据的多个事务中，一个事务修改数据后，其他事务何时能看到修改后的结果。

  • MySQL数据库事务隔离级别主要有四种：

    • Serializable：串行化，一个事务一个事务的执行。
    • Repeatable read：可重复读，无论其他事务是否修改并提交了数据，在这个事务中看到的数据值始终不受其他事务影响。
    • Read committed：读取已提交，其他事务提交了对数据的修改后，本事务就能读取到修改后的数据值。
    • Read uncommitted：读取未提交，其他事务只要修改了数据，即使未提交，本事务也能看到修改后的数据值。
    • MySQL数据库默认使用可重复读（ Repeatable read）。

  • 使用乐观锁的时候，如果一个事务修改了库存并提交了事务，那其他的事务应该可以读取到修改后的数据值，所以不能使用可重复读的隔离级别，应该修改为读取已提交（Read committed）。

  • 修改方式：

sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf

修改完成之后重启
sudo service mysql restart

 

 transaction-isolation=READ-COMMITTED

 

黑马程序员官方
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
博客
自学前端需要达到什么水平才能去找工作？来看看这套前端学习路线图
11-26 2万+
自学前端需要达到什么水平？当然是水平越高，越容易找到工作。在竞争这么激烈的2020年，就需要更加的努力，充实自己，让自己不被代替！看了好多的回答，大家都是再说学到什么水平能找到工作，我就来分享干货吧！祝看到这篇干货的小伙伴，工作步步高升！黑马程序员学习路线图及能掌握的能力（总，以下会分阶段，加上配套学习视频，小伙伴可继续往下看！）第一阶段：HTML5+css配套学习视频：前端小白零基础入门HTML5+CSS3完整视频：http://yun.itheima.co.
博客
软件测试全套教程，2020年全新软件测试学习路线图
05-04 1万+
2020年全新的软件测试学习路线图来袭，零基础入行入职必备学习教程，高质量免费资源在线学习！还在等什么，想学习软件测试的小伙伴，快来点击进入学习状态吧！一、基础入门课程亮点1. 熟悉计算机相关概念。2. 掌握基础的测试理论。3. 熟练掌握HTML常用标签input。4. 掌握使用CSS选择器。配套学习视频：软件测试基础入门之HTML基础​软件测试基础入门......
博客
Java多线程编程，来看这篇就够了！全新Java多线程教程！
06-25 6919
对于Java程序员来讲，Spring全家桶几乎可以搞定一切，Spring全家桶便是精妙的招式，多线程就是内功心法很重要的一块，线上出现性能问题，多线程更是不可回避的问题。因此多线程基础知识对于高级程序员的重要性不必言语！很多公司在面试高级程序员时候，多线程相关知识也必定是考核的标准之一。那我们为什么要学习多线程呢？掌握Java多线程可以：应对面试、优化之路、深入理解。应对面试在面试中，求职...
博客
QT教程，QT从入门到实战教程完整版
06-17 7万+
Qt是一个跨平台开发框架，可以使用C++和Qml开发，同时它又不仅仅只是开发框架，它也是一种技术策略，可以让你快速、高效地设计、开发、部署和维护软件，同时在所有设备上提供无缝的用户体验。因而，对于C/C++工程师而言，QT是必须要学习的一个跨平台开发框架，今天分享一个QT教程！课程亮点1，知识体系完备，内容精炼2，脉络清晰，讲解过程把握知识主线。3，结合工作实践及分析应用，培养...
博客
软件测试人员应该如何介绍自己测试过的项目
05-09 4万+
测试人员在找工作的过程中，通常有一个问题是很难绕开的。就是要如何向别人介绍自己之前做过的项目。下面我们就这个问题简单的做一些分析。要解决这个问题，大体上可以分为如下几个步骤：1、对项目进行基本介绍2、说明自己负责测试的模块3、针对部分模块展开进行说明一. 对项目进行基本介绍以下就以一个简单的项目进行介绍说明：最近测试的Tpshop项目是一个B/S架构的Web项...
博客
软件测试全套教程，软件测试自学线路图
07-09 19万+
软件测试：软件测试是为了发现程序中的错误而执行程序的过程。通俗的说，软件测试需要在发布软件之前，尽可能的找软件的错误，尽量避免在发布之后给用户带来不好的体验，并要满足用户使用的需求。现在市面上这么多软件，每个软件背后都有软件测试工程师的功劳，这也造就了软件测试行业前景非常好，今天我就分享一下自学线路图，及全套教程！软件测试学习线路图点击查看大图第一阶段：该...
博客
Python入门教程完整版（懂中文就能学会）
09-28 18万+
今天本宝宝给大家带来了干货，Python入门教程完整版，完整版啊！完整版！言归正传，我来给大家介绍一下这套教程，希望每个小伙伴都沉迷学习，无法自拔！本套教程学习时间15天1-3天内容：为Linux基础命令4-13天内容：为Python基础教程14-15 天内容：为飞机大战项目演练第一阶段（1-3天）：该阶段首先通过介绍不同领域的三种操作系统，操作系统的发展简史以及...
博客
Java学习路线图，全套Java基础视频教程
09-07 23万+
深知广大爱好Java的人学习是多么困难，没视频没资源，上网花钱还老被骗。为此我呕心沥血整理了这套Java教程，不管你是不懂电脑的小白，还是已经步入开发的大牛，这套路线路你都值得拥有，小白看上面的视频可以成功学会Java并且顺利工作，大神看了上面的资源肯定会谆谆乐道，教程的宗旨就是分享，专业，便利，让喜爱Java的人，都能平等的学习。首先建立好开发环境非常重要，工欲善其事，必先利其器。做任何开发.........
博客
千字Java学习路径，超全！从零基础到精通~
07-01 405
Java并发编程实践》是并发编程的里程碑著作，从并发编程的基本理论入手，逐步介绍设计Java并发程序时的重要设计原则、设计模式及思维模式，使开发人员能够快速领悟Java并发编程要领，迅速构建大规模并发应用程序。这本书详细讲解了Java SE的所有内容及其原理，如果你能彻底掌握这本书，将会为你未来的技术进阶打下坚实的基础。《Java核心技术卷2：高级特征》全面覆盖了Java技术的高级主题，对Java技术的阐述精确到位，叙述方式深入浅出，并包含大量示例，帮助读者充分理解Java语言及其类库的相关特性。
博客
Java若依框架入门，初始化项目、Maven构建等配置
06-28 964
这些版本的框架为开发者提供了多样化的选择，无论是传统的Web应用、现代化的前后端分离应用，还是复杂的微服务架构和跨平台的移动端应用，都能找到合适的若依框架版本来满足开发需求。
博客
Python学习指南：6个步骤快速上手
06-27 979
Python 是一种高级解释型编程语言，由 Guido van Rossum 创建，首次发布于1991年。它注重代码的可读性，其语法允许程序员用比C++或Java更少的代码行来表达相同的概念。Python 支持多种编程范式，包括过程式编程、面向对象编程和函数式编程。简单来说，这意味着它非常灵活，可以用不同的方式编写代码，无论是为计算机设定一系列任务（过程式），创建事物或概念的数字模型（面向对象），还是像处理数学问题一样处理代码（函数式）。
博客
鸿蒙开发培训，5000家App已加入鸿蒙生态，华为鸿蒙设备增长至9亿
06-24 403
在2024年华为开发者大会上，华为终端BG CEO余承东宣布，目前鸿蒙生态设备已超过9亿，HarmonyOS开发者人数达到了254万，鸿蒙学堂的参与人次达到了435万。余承东指出，鸿蒙原生应用已进入全面冲刺阶段，并呼吁更多开发者加入鸿蒙生态。华为也承诺将持续提供完善的开发工具及资金扶持。鸿蒙生态的快速发展为开发者提供了广阔的前景和机遇。那么，如何投身鸿蒙技术，成为一名合格的鸿蒙开发者呢？以下是详细的学习路径，帮助你从基础到进阶，逐步掌握鸿蒙开发的核心技术。
博客
Python入门，Python爬虫基础知识
06-19 541
网络爬虫（Web Crawler 或 Spider）是一种在互联网上自动获取信息的程序。它根据设定的规则，从互联网上下载网页、图片、视频等内容，并提取有用信息进行处理。简而言之，网络爬虫就像是在互联网上自动“爬行”的程序，从一个或多个初始网页开始，读取网页内容，找到其中的链接，再通过这些链接找到下一个网页，如此循环，直到抓取完所有目标网页。网络爬虫的应用非常广泛，如搜索引擎的网页抓取、数据挖掘、网站监测等。例如，搜索引擎通过爬虫技术抓取网页信息，建立索引数据库，以便用户进行关键词搜索时能快速找到相关信息。
博客
Java入门，深入理解Java平台及其关键特性
06-19 477
Java的标志性特点是“一次编写，到处运行”（Write once, run anywhere）。通过字节码和Java虚拟机（JVM），Java可以在不同的操作系统和硬件上运行，这种跨平台的抽象屏蔽了底层的细节，使得Java程序具备了很强的可移植性。
博客
5分钟上手Python爬虫，轻松掌握爬虫技巧
06-17 1240
本文的重点在于引导读者初步掌握爬虫技术。入门并不难，但在实际操作中可能会遇到一些困难，比如有些网站不允许直接访问，需要登录或进行人机验证等。因此，建议先从爬取一些新闻资讯类的网站开始，因为这样相对容易。涉及用户支付等敏感信息的网站就不那么容易获取了。因此，在入门阶段，不要选择太复杂的网站，先尝试简单的爬取。一旦理解了基本原理，遇到问题时可以考虑添加组件或使用第三方库来解决。# 初始化彩色输出init()# 定义颜色# 打印初始信息。
博客
Java面试重点知识体系解析及高效复习指南
06-12 366
Java 后端的知识体系非常庞大，在准备面试时，需要优先抓住重点进行复习。
博客
鸿蒙开发培训，5分钟学会鸿蒙开发语言关键知识点
06-11 804
ArkTS 是 HarmonyOS 的主要开发语言。它在 TypeScript 的基础上进行了优化和扩展，保留了 TypeScript 的优点，同时屏蔽了其缺点，并与 ArkUI 框架一起构建了鸿蒙应用。本文将介绍 ArkTS 的相关内容。基于上述需求，ArkTS 强制使用静态类型。这意味着在 ArkTS 中，声明变量、函数参数和返回值时必须指定类型，并在编译时进行严格的类型检查。
博客
深入理解三大经典算法：快速排序、动态规划背包问题和Dijkstra算法
06-06 364
很多业务场景需要算法，成熟的算法可以提高效率，减少不必要出现的问题，规避风险！今天给大家总结了3个在实现业务场景中使用到的算法，分享给你。
博客
Java学习：Java中的常见数据结构以及其示例代码
06-05 273
这些示例代码展示了如何使用Java中的一些常见数据结构。你可以根据具体需求进行修改和扩展，以适应不同的应用场景。了解和熟练使用这些数据结构，将帮助你编写出更高效、可维护的代码。在Java编程中，了解和掌握常见的数据结构是至关重要的。
博客
掌握Java的80%：面向对象与并发编程
06-04 664
Java作为一种广泛使用的编程语言，其强大之处在于其面向对象的特性和对并发编程的卓越支持。作为一名程序员，深刻理解Java的面向对象概念、集合框架、多线程与并发编程，以及Java虚拟机（JVM）的基础知识，对于编写高效、可维护的代码至关重要。本文将引导你快速掌握这些核心概念。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值