瑞吉外卖手机端（用qq邮箱实现登录）

最新推荐文章于 2024-05-06 18:26:10 发布
最新推荐文章于 2024-05-06 18:26:10 发布
阅读量508 收藏
点赞数
分类专栏： JAVA 文章标签： java spring mybatis redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzbzxzzdf/article/details/130443210
版权

目录

DishController 

ShoppingCartController  

 AddressBookController 

 具体的代码可到：reggie_take_out: 瑞吉外卖——功能实现 - Gitee.com

如果打开就报错，看看是不是没有开启redis。

页面展示：

 

 

 

 

 

 

 

 具体代码：

DishController 

package com.itheima.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.reggie.common.R;
import com.itheima.reggie.dto.DishDto;
import com.itheima.reggie.entity.Category;
import com.itheima.reggie.entity.Dish;
import com.itheima.reggie.entity.DishFlavor;
import com.itheima.reggie.service.CategoryService;
import com.itheima.reggie.service.DishFlavorService;
import com.itheima.reggie.service.DishService;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 菜品管理
 */
@RestController
@Slf4j
@RequestMapping("/dish")
public class DishController {
    @Autowired
    private DishService dishService;

    @Autowired
    private DishFlavorService dishFlavorService;

    @Autowired
    private CategoryService categoryService;

    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 新增菜品
     * @param dishDto
     * @return
     */
    //@RequestBody 网页是json数据时要加此注解才能接收
    @PostMapping
    public R<String> save(@RequestBody DishDto dishDto){
        log.info(dishDto.toString());

        dishService.saveWithFlavor(dishDto);

        //清理所有菜品的缓存数据
        //Set keys = redisTemplate.keys("dish_*");
        //redisTemplate.delete(keys);

        //清理某个分类下面的菜品缓存数据
        String key = "dish_"+dishDto.getCategoryId()+"_1";
        redisTemplate.delete(key);

        return R.success("菜品添加成功");
    }

    /**
     * 菜品信息分页查询
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    @GetMapping("/page")
    public R<Page> page(int page,int pageSize,String name){

        //构造分页构造器对象
        Page<Dish> pageInfo = new Page<>(page,pageSize);
        Page<DishDto> dishDtoPage = new Page<>();

        //条件构造器
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        //添加过滤条件
        queryWrapper.like(name != null,Dish::getName,name);
        //添加排序条件
        queryWrapper.orderByDesc(Dish::getUpdateTime);
        //执行分页查询
        dishService.page(pageInfo,queryWrapper);

        //对象拷贝
        BeanUtils.copyProperties(pageInfo,dishDtoPage,"records");

        List<Dish> records = pageInfo.getRecords();

        List<DishDto> list = records.stream().map((item) -> {
            DishDto dishDto = new DishDto();

            BeanUtils.copyProperties(item,dishDto);

            Long categoryId = item.getCategoryId();//分类id
            //根据id查询分类对象
            Category category = categoryService.getById(categoryId);
            if (category != null){
                String categoryName = category.getName();
                dishDto.setCategoryName(categoryName);
            }
            return dishDto;
        }).collect(Collectors.toList());

        dishDtoPage.setRecords(list);

        return R.success(dishDtoPage);
    }

    /**
     * 根据id查询菜品信息和对应的口味信息
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public R<DishDto> get(@PathVariable Long id){

        DishDto dishDto = dishService.getByIdWithFlavor(id);

        return R.success(dishDto);
    }

    /**
     * 修改菜品
     * @param dishDto
     * @return
     */
    //@RequestBody 网页是json数据时要加此注解才能接收
    @PutMapping
    public R<String> update(@RequestBody DishDto dishDto){
        log.info(dishDto.toString());

        dishService.updateWithFlavor(dishDto);

        //清理所有菜品的缓存数据
        //Set keys = redisTemplate.keys("dish_*");
        //redisTemplate.delete(keys);

        //清理某个分类下面的菜品缓存数据
        String key = "dish_"+dishDto.getCategoryId()+"_1";
        redisTemplate.delete(key);

        return R.success("修改菜品成功");
    }

    /**
     * 根据条件查询对应的菜品数据
     * @param dish
     * @return
     */
    @GetMapping("/list")
    public R<List<DishDto>> list(Dish dish){
        List<DishDto> dishDtoList = null;

        String key = "dish_"+dish.getCategoryId()+"_"+dish.getStatus();

        //先从redis中获取缓存数据
        dishDtoList = (List<DishDto>) redisTemplate.opsForValue().get(key);

        if (dishDtoList!=null){
            //如果存在，直接返回，无需查询数据库
            return R.success(dishDtoList);
        }

        //构造查询条件
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(dish.getCategoryId() != null,Dish::getCategoryId,dish.getCategoryId());
        //添加条件，查询状态为1（起售状态）的菜品
        queryWrapper.eq(Dish::getStatus,1);
        //添加排序条件
        queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);

        List<Dish> list = dishService.list(queryWrapper);

        dishDtoList = list.stream().map((item) -> {
            DishDto dishDto = new DishDto();

            BeanUtils.copyProperties(item,dishDto);

            Long categoryId = item.getCategoryId();//分类id
            //根据id查询分类对象
            Category category = categoryService.getById(categoryId);
            if (category != null){
                String categoryName = category.getName();
                dishDto.setCategoryName(categoryName);
            }
            //当前菜品的id
            Long dishID = item.getId();
            LambdaQueryWrapper<DishFlavor> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(DishFlavor::getDishId,dishID);
            List<DishFlavor> dishFlavorList = dishFlavorService.list(lambdaQueryWrapper);
            dishDto.setFlavors(dishFlavorList);
            return dishDto;
        }).collect(Collectors.toList());

        //如果不存在，需要查询数据库，将查询到的数据缓存到redis中
        redisTemplate.opsForValue().set(key,dishDtoList,60, TimeUnit.MINUTES);

        return R.success(dishDtoList);
    }


    /**
     * 根据ids删除菜品
     * @param ids
     * @return

    @DeleteMapping
    public R<String> delete(Long ids){
        log.info("删除菜品，id为：{}",ids);
        dishService.remove(ids);
        dishFlavorService.removeById(ids);
        return R.success("分类信息删除成功");
    }
     */
    @DeleteMapping
    public R<String> delete(String ids) {
        log.info("售卖状态，id为：{}",ids);
        String[] split = ids.split(",");
        List<Long> Ids = new ArrayList<>();
        for (int i = 0; i < split.length; i++) {
            dishService.remove(Long.valueOf(split[i]));
        }
        return R.success("分类信息删除成功");
    }
    /**
     * 售卖状态单个
     * @param ids
     * @return

    @PostMapping("/status/{status}")
    public R<String> status(@PathVariable("status") Integer status, Long ids){
        log.info("售卖状态，id为：{}",ids);
        Dish dish = dishService.getById(ids);
        if (dish!=null){
            dish.setStatus(status);
            dishService.updateById(dish);
            return R.success("售卖状态修改成功");
        }
        return R.error("售卖状态修改异常");
    }
     */
    /**
     * 批量修改售卖状态
     * @param status
     * @param ids
     * @return
     */
    @PostMapping("/status/{status}")
    public R<String> status(@PathVariable("status") Integer status,String ids) {
        log.info("售卖状态，id为：{}",ids);
        String[] split = ids.split(",");
        List<Long> Ids = new ArrayList<>();
        for (int i = 0; i < split.length; i++) {
            Ids.add(Long.valueOf(split[i]));
        }
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(ids!=null,Dish::getId,Ids);
        List<Dish> list = dishService.list(queryWrapper);
        for (Dish dish : list) {
            if (dish!=null)
            {
                dish.setStatus(status);
                dishService.updateById(dish);
            }

        }
        return R.success("售卖状态修改成功");

    }
}

ShoppingCartController  

package com.itheima.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.itheima.reggie.common.BaseContext;
import com.itheima.reggie.common.R;
import com.itheima.reggie.entity.ShoppingCart;
import com.itheima.reggie.service.ShoppingCartService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.net.BCodec;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 购物车
 */
@Slf4j
@RestController
@RequestMapping("/shoppingCart")
public class ShoppingCartController {

    @Autowired
    private ShoppingCartService shoppingCartService;

    /**
     * 添加购物车
     * @param shoppingCart
     * @return
     */
    @PostMapping("/add")
    public R<ShoppingCart> add(@RequestBody ShoppingCart shoppingCart){
        log.info("购物车数据：{}",shoppingCart);

        //设置用户id 指定当前是那个用户的购物车数据
        Long currentId = BaseContext.getCurrentId();
        shoppingCart.setUserId(currentId);

        //查询当前菜品或者套餐是否在购物车中
        Long dishId = shoppingCart.getDishId();
        LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ShoppingCart::getUserId,currentId);
        if (dishId != null){
            //添加到购物车的是菜品
            queryWrapper.eq(ShoppingCart::getDishId,dishId);
        }else {
            //添加到购物车的是套餐
            queryWrapper.eq(ShoppingCart::getSetmealId,shoppingCart.getSetmealId());
        }

        //SQl:select * from shopping_cart where user_id = ? and dish_id/setmeal_id = ?
        //查询当前菜品或者套餐是否在购物车中
        ShoppingCart cartServiceOne = shoppingCartService.getOne(queryWrapper);

        if (cartServiceOne != null){
            //如果已经存在，就在原来数量基础上加一
            Integer number = cartServiceOne.getNumber();
            cartServiceOne.setNumber(number+1);
            shoppingCartService.updateById(cartServiceOne);
        }else {
            //如果不存在，则添加到购物车，数量默认就是一
            shoppingCart.setNumber(1);
            shoppingCart.setCreateTime(LocalDateTime.now());
            shoppingCartService.save(shoppingCart);
            cartServiceOne = shoppingCart;
        }
        return R.success(cartServiceOne);
    }

    /**
     * 减少购物车
     * @param shoppingCart
     * @return
     */
    @PostMapping("/sub")
    public R<ShoppingCart> sub(@RequestBody ShoppingCart shoppingCart){
        Long dishId = shoppingCart.getDishId();
        LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
        if (dishId != null){
            //减少购物车的是菜品
            queryWrapper.eq(ShoppingCart::getDishId,dishId);
            queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
        }else {
            //减少购物车的是套餐
            queryWrapper.eq(ShoppingCart::getSetmealId,shoppingCart.getSetmealId());
        }
        ShoppingCart cart = shoppingCartService.getOne(queryWrapper);
        cart.setNumber(cart.getNumber()-1);
        Integer LatestNumber = cart.getNumber();
        if (LatestNumber>0){
            //对数据进行更新
            shoppingCartService.updateById(cart);
        }else if (LatestNumber == 0){
            //如果购物车为0，那么把菜品从购物车删除
            shoppingCartService.removeById(cart.getId());
        }else {
            return R.error("操作异常");
        }
        return R.success(cart);
    }
    /**
     * 减少购物车
     * @param shoppingCart
     * @return

    @PostMapping("/sub")
    public R<ShoppingCart> sub(@RequestBody ShoppingCart shoppingCart){
        Long dishId = shoppingCart.getDishId();
        LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();

        //代表数量减少的是菜品数量
        if(dishId!=null){
            //通过dishID查看购物车对象
            queryWrapper.eq(ShoppingCart::getDishId,dishId);
            //加条件以防删除其他人的购物车
            queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
            ShoppingCart cart = shoppingCartService.getOne(queryWrapper);
            cart.setNumber(cart.getNumber()-1);
            Integer LatestNumber = cart.getNumber();
            if (LatestNumber>0){
                //对数据进行更新
                shoppingCartService.updateById(cart);
            }else if (LatestNumber == 0){
                //如果购物车为0，那么把菜品从购物车删除
                shoppingCartService.removeById(cart.getId());
            }else {
                return R.error("操作异常");
            }
            return R.success(cart);
        }

        //代表减少了套餐数量
        Long setmealId = shoppingCart.getSetmealId();
        if (setmealId!=null){
            queryWrapper.eq(ShoppingCart::getSetmealId,setmealId);
            ShoppingCart cart = shoppingCartService.getOne(queryWrapper);
            cart.setNumber(cart.getNumber()-1);
            Integer LatestNumber = cart.getNumber();
            if (LatestNumber>0){
                //对数据进行更新
                shoppingCartService.updateById(cart);
            }else if (LatestNumber==0){
                //如果购物车为0，那么把菜品从购物车删除
                shoppingCartService.removeById(cart.getId());
            }else {
                return R.error("操作异常");
            }
            return R.success(cart);
        }
        //如果不是减少菜品和套餐
        return R.error("操作异常");
    }
     */

    /**
     * 查看购物车
     * @return
     */
    @GetMapping("/list")
    public R<List<ShoppingCart>> list(){
        log.info("查看购物车...");

        LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ShoppingCart::getUserId,BaseContext.getCurrentId());
        queryWrapper.orderByAsc(ShoppingCart::getCreateTime);

        List<ShoppingCart> list = shoppingCartService.list(queryWrapper);

        return R.success(list);
    }

    /**
     * 清空购物车
     * @return
     */
    @DeleteMapping("/clean")
    public R<String> clean(){
        //SQl：select from shopping_cart where user_id = ?

        LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ShoppingCart::getUserId,BaseContext.getCurrentId());

        shoppingCartService.remove(queryWrapper);

        return R.success("清空购物车成功");
    }
}

 AddressBookController 

package com.itheima.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.reggie.common.BaseContext;
import com.itheima.reggie.common.R;
import com.itheima.reggie.entity.AddressBook;
import com.itheima.reggie.service.AddressBookService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 地址簿管理
 */
@Slf4j
@RestController
@RequestMapping("/addressBook")
public class AddressBookController {

    @Autowired
    private AddressBookService addressBookService;

    /**
     * 新增
     */
    @PostMapping
    public R<AddressBook> save(@RequestBody AddressBook addressBook) {
        addressBook.setUserId(BaseContext.getCurrentId());
        log.info("addressBook:{}", addressBook);
        addressBookService.save(addressBook);
        return R.success(addressBook);
    }

    /**
     * 设置默认地址
     */
    @PutMapping("default")
    public R<AddressBook> setDefault(@RequestBody AddressBook addressBook) {
        log.info("addressBook:{}", addressBook);
        LambdaUpdateWrapper<AddressBook> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AddressBook::getUserId, BaseContext.getCurrentId());
        wrapper.set(AddressBook::getIsDefault, 0);
        //SQL:update address_book set is_default = 0 where user_id = ?
        addressBookService.update(wrapper);

        addressBook.setIsDefault(1);
        //SQL:update address_book set is_default = 1 where id = ?
        addressBookService.updateById(addressBook);
        return R.success(addressBook);
    }

    /**
     * 根据id查询地址
     */
    @GetMapping("/{id}")
    public R get(@PathVariable Long id) {
        AddressBook addressBook = addressBookService.getById(id);
        if (addressBook != null) {
            return R.success(addressBook);
        } else {
            return R.error("没有找到该对象");
        }
    }

    /**
     * 查询默认地址
     */
    @GetMapping("default")
    public R<AddressBook> getDefault() {
        LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AddressBook::getUserId, BaseContext.getCurrentId());
        queryWrapper.eq(AddressBook::getIsDefault, 1);

        //SQL:select * from address_book where user_id = ? and is_default = 1
        AddressBook addressBook = addressBookService.getOne(queryWrapper);

        if (null == addressBook) {
            return R.error("没有找到该对象");
        } else {
            return R.success(addressBook);
        }
    }

    /**
     * 查询指定用户的全部地址
     */
    @GetMapping("/list")
    public R<List<AddressBook>> list(AddressBook addressBook) {
        addressBook.setUserId(BaseContext.getCurrentId());
        log.info("addressBook:{}", addressBook);

        //条件构造器
        LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(null != addressBook.getUserId(), AddressBook::getUserId, addressBook.getUserId());
        queryWrapper.orderByDesc(AddressBook::getUpdateTime);

        //SQL:select * from address_book where user_id = ? order by update_time desc
        return R.success(addressBookService.list(queryWrapper));
    }
}

 具体的代码可到：reggie_take_out: 瑞吉外卖——功能实现 - Gitee.com

手持烟火以谋生，心怀诗意以谋爱

竹院逢话
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
瑞吉外卖+MongoDB+qq邮箱验证，实验所有源码+数据库全拷贝
06-02
瑞吉外卖所有功能实现，以及后端将MySQL更改为MongoDB数据库。根据室友建议，我把Logo也改了改，方便大家使用。
SB_8_瑞吉外卖项目优化_redis缓存短信验证码_redis缓存菜品信息_springCache_redis缓存套餐数据
xujunming668的博客
01-08 2032
瑞吉外卖项目优化-Day01 课程内容 环境搭建 缓存短信验证码 缓存菜品信息 SpringCache 缓存套餐数据 前言 1). 当前系统存在的问题 之前我们已经实现了移动端菜品展示、点餐、购物车、下单等功能，但是由于移动端是面向所有的消费者的，请求压力相对比较大，而我们当前所有的数据查询都是从数据库MySQL中直接查询的，那么可能就存在如下问题： 频繁访问数据库，数据库访问压力大，系统性能下降，用户体验较差。 2). 解决该问题的方法 要解决我们上述提到的问题，就可以使用我们前面学习的一
瑞吉外卖项目----（2）缓存优化
LL的博客
08-01 440
缓存优化
瑞吉外卖 qq邮箱实现验证码登录
weixin_55845798的博客
05-21 284
编写 Controller。获得 SMTP 授权码。
SpringBoot项目 瑞吉外卖（9）邮箱服务
Falling_Asteroid的博客
03-09 237
对标网课80P-88P
【瑞吉外卖】SpringBoot使用邮件发送短信验证码--完善用户登录功能
06-24
黑马程序员---瑞吉外卖--SpringBoot项目 新增sendMail（）方法，用户登录时使用QQ邮件发送验证码，完善用户登录功能。 亲测有效！
黑马瑞吉外卖之移动端验证码登录使用qq邮箱
jgdabc的博客
10-01 5579
pc端的后台管理我们剩下有订单明细还没有进行开发，由于订单这边需要移动端下单后才可以看到订单，所以我们需要去先在移动端开发一些功能后，再回过头让订单这边进行一个展示。 首先移动端开发的话，我们首先遇到的应该就是登录的问题。移动端登录这边我们验证码发送的话我们这边采用qq邮箱的验证码进行登录。既然是用户登录这里的话，其实我们还需要这样对应的数据模型。我们先看前端页面代码 这里给到的登录页面这里，其实我们可以稍微修改一下，之前这里是提示的输入的手机号码，我们这里要用qq邮箱验证登录的话，其实我们可以要求输入邮
瑞吉外卖QQ邮箱登录
qq_63448522的博客
07-24 9471
原教程为阿里云获取短信验证码进行登录，为了节约成本，我们使用QQ邮箱即可实现验证码登录。
瑞吉外卖qq邮箱验证码登录
ricardo_szc的博客
08-03 250
进入qq邮箱没有开启服务要选择开启，开启了的话需要点击管理服务，进入管理服务的安全设置点击生成授权码微信扫码短信验证然后需要你保存好这个授权码后面要用。
【Java项目】瑞吉外卖保姆级学习笔记(改项目名称+改邮件验证码登录+功能补充)
热门推荐
Sihang_Xie的博客
10-28 2万+
有什么适合学完Spring Boot练手的项目？如何开发一套外卖软件项目？如何把黑马的瑞吉外卖项目改成邮箱验证码登录？如何把黑马的瑞吉外卖包装成自己的项目？看完本篇博文，相信你会得到答案。
spring boot+elementUI前后端分离瑞吉外卖
06-29
# 瑞吉外卖 ## 软件开发整体介绍 ### 软件开发流程 - 需求分析 ：产品原型、需求分析 - 设计：产品文档、UI界面设计、概要设计、详细设计、数据库设计 - 编码： 项目代码、单元测试 - 测试： 测试用例、测试报告 ...
个人实现瑞吉外卖改良后源码
05-22
个人实现的瑞吉外卖——改良后源码
瑞吉外卖项目完整篇（vue+springboot+redis+mybatis-plus）
04-29
该资源是我学习完瑞吉外卖项目后将所有的功能模块都实现了。所有的接口在后端都有相应的代码去做相应的操作。前端的请求接口在后端都有对应的实现。 下载，解压后 1、有sql文件在MySQL工具中创建数据库和表。 2、...
瑞吉外卖（2） - 登录功能开发、测试验证
qq_39123467的博客
05-26 1274
瑞奇外卖（2） - 登录功能开发、测试验证
【瑞吉外卖】学习笔记-day5:（三）手机验证码登录（用邮件发送代替）
qq_50298703的博客
10-26 2424
瑞吉外卖项目学习笔记：手机验证码登录（用邮件发送代替）
瑞吉外卖（23）- 手机验证码登录功能
qq_39123467的博客
09-27 2452
瑞吉外卖（23）- 手机验证码登录功能
黑马-瑞吉外卖 day5 套餐管理+手机验证码登录
weixin_49465828的博客
06-13 213
黑马Java企业级入门项目——瑞吉外卖：全程跟练代码+笔记总结+内容精进+多种方法尝试。全网最详细保姆级笔记，适合初学者。
猿创征文｜瑞吉外卖——移动端_邮箱验证码登录
m0_65144570的博客
09-12 1147
瑞吉外卖的移动端中邮箱验证码的操作。
Linux下网络编程-简易Epll服务器和客户端
最新发布
weixin_45256307的博客
05-06 418
Linux下网络编程-简易Epll服务器和客户端

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值