微信小程序+JAVA实现微信支付

news2024/11/26 14:30:07

时隔两年再次回归

本文主要讲的是小程序实现微信支付功能,后台采用JAVA。

一.准备工作

1.小程序
2.微信商户号

1.商户号申请

这里对小程序的申请不做赘述。
如果没有微信商户号的同学,点击该链接https://pay.weixin.qq.com/,按照下属步骤进行商户号申请。
在这里插入图片描述

扫码之后点击"成为商家",这里主要有个体工商户和企业,按照事实填写,然后按照步骤填写就行了。
主要需要营业执照,法人信息,公账信息等。

2.微信商户号关联小程序

在这里插入图片描述

点击"产品中心"的"开发配置",点击"新增授权申请单"。

在这里插入图片描述
输入你的小程序appid,点击下一步。

在这里插入图片描述
然后到小程序后台>微信支付>商户号管理里,会出现一个申请单,点击“查看”。

在这里插入图片描述
点击确认绑定,这样你的商户号就与小程序进行绑定了。

二.代码编写

1.小程序

小程序这块主要是调用一下后台接口获取参数,然后通过参数拉起微信支付。

orderPay(payInfo){
  let that = this
  wx.requestPayment({
    'timeStamp': payInfo.timeStamp,
    'nonceStr': payInfo.nonceStr,
    'package': payInfo.package,
    'signType': payInfo.signType,
    'paySign': payInfo.paySign,
    'success': function (res) {
		// 支付成功的回调
    },
    'fail': function (res) {
      console.log(JSON.stringify(res));
      wx.showToast({title: '支付失败', icon: 'none',duration: 2000,mask: true})
    }
  })
},

这里的payInfo就是从后台接口获取的支付参数,通过wx.requestPayment就可以拉起微信支付了。具体的参数信息在下面会进行讲解。

2.服务端(JAVA)

服务端这边主要是三个接口:

1.提交支付订单

这个主要是为了获取提交支付订单,获取前端拉起支付的参数。

2.微信支付回调

当你小程序拉起支付并且成功支付后,会将支付结果回调到这个接口

3.支付订单查询

你也可以主动通过订单号查询支付订单状态

下面是我的代码,包含了我的业务代码,大家将就着看吧

controller:

import com.smart.iot.gmt.app.bean.CommonReponse;
import com.smart.iot.gmt.app.constant.ResponseContant;
import com.smart.iot.gmt.app.constant.SessionKeyConstants;
import com.smart.iot.gmt.app.request.wechatPay.PaymentRequest;
import com.smart.iot.gmt.app.request.wechatPay.QueryPayOrderRequest;
import com.smart.iot.gmt.app.response.wechat.WechatPaymentResponse;
import com.smart.iot.gmt.app.response.wechat.WechatQueryPayOrderResponse;
import com.smart.iot.gmt.app.service.CommonService;
import com.smart.iot.gmt.app.service.pay.wechat.WxPayService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;

@Slf4j
@RestController
public class WxPayController {

    @Autowired
    private WxPayService service;
    @Autowired
    private CommonService commonService;

    /**
     *
     * @author Rick chou
     * @date 2024/7/18 15:33
     * 提交支付
     *
     */
    @PostMapping("/payment")
    public CommonReponse payment(@RequestBody PaymentRequest paymentRequest) {
        Integer price = paymentRequest.getPrice();
        String orderId = paymentRequest.getOrderId();
        Map<String, Object> result = service.payment(price, orderId, userId);
        CommonReponse commonResponse = commonService.getCommonResponse(ResponseContant.SUCCESS_CODE, ResponseContant.SUCCESS, result);
        return new WechatPaymentResponse(commonResponse,result);
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/15 16:57
     * 微信支付回调
     *
     */
    @PostMapping("/payNotify")
    public void payNotify(HttpServletRequest request) throws Exception {
        service.payNotify(request);
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/15 16:57
     * 支付查询
     *
     */
    @PostMapping("/queryPayOrder")
    public CommonReponse queryPayOrder(@RequestBody QueryPayOrderRequest request) {
        Map<String, Object> result = service.queryPayOrder(request);
        CommonReponse commonResponse = commonService.getCommonResponse(ResponseContant.SUCCESS_CODE, ResponseContant.SUCCESS, result);
        return new WechatQueryPayOrderResponse(commonResponse,result);
    }
}

service:

import com.alibaba.fastjson.JSON;
import com.smart.iot.constant.RedisKeys;
import com.smart.iot.device.dto.LockNotifyMessageDTO;
import com.smart.iot.device.service.DeviceRedisCacheService;
import com.smart.iot.gmt.app.annotation.SpringUtil;
import com.smart.iot.gmt.app.bo.*;
import com.smart.iot.gmt.app.entity.MemberOrderDetailEntity;
import com.smart.iot.gmt.app.enums.MemberOrderStateEnum;
import com.smart.iot.gmt.app.request.wechatPay.QueryPayOrderRequest;
import com.smart.iot.gmt.app.service.LockNotifyMessageService;
import com.wechat.pay.java.service.payments.model.Transaction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;
import java.util.Map;

@Slf4j
@Service
public class WxPayService {

    public Map<String, Object> payment(Integer price, String orderId, String userId){
        Map<String, Object> result = WechatPayBo.payment(price, orderId, userId);
        return result;
    }

    @Transactional
    public void payNotify(HttpServletRequest request) throws Exception {
        Transaction parse = WechatPayBo.payNotify(request);
        updateAccountDetail(parse,false);
    }

    @Transactional
    public Map<String,Object> queryPayOrder(QueryPayOrderRequest request) {
        String orderId = request.getOrderId();
        Transaction parse = WechatPayBo.queryPayOrder(orderId);
        return updateAccountDetail(parse,true);
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 11:03
     * 支付回调处理
     * 1.更新订单状态
     * 2.添加支付记录
     * 3.通知小程序
     *
     */
    public Map<String,Object> updateAccountDetail(Transaction parse, boolean active) {
        String orderId = parse.getOutTradeNo();
        Transaction.TradeStateEnum tradeState = parse.getTradeState();
        if(tradeState==Transaction.TradeStateEnum.SUCCESS) {
            if(OrderBo.check(orderId).getState() == MemberOrderStateEnum.IN_PROGRESS.code) {
                OrderBo order = this.updateOrder(orderId);
                this.renewMember(orderId);
                this.saveRecord(parse, order.getUserId());
            }
        }
        if(active){
            return JSON.parseObject(buildParse(parse),Map.class);
        }else{
            this.payNoticeMessage(parse,orderId);
        }
        return null;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/19 15:31
     * 更新订单状态
     *
     */
    private OrderBo updateOrder(String orderId){
        OrderBo order = OrderBo.check(orderId);
        order.finish();
        String key = RedisKeys.ADD_ORDER_PAY_TIME_PREFIX + orderId;
        SpringUtil.getBean(DeviceRedisCacheService.class).delete(key);
        return order;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/19 15:32
     * 更新会员时间
     *
     */
    private void renewMember(String orderId){
        MemberOrderDetailEntity orderDetail = OrderDetailBo.getByOrderId(orderId);
        UserMemberBo.renew(orderDetail);
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/19 15:33
     * 保存支付记录
     *
     */
    private void saveRecord(Transaction parse,String userId){
        String orderId = parse.getOutTradeNo();
        Integer amount = parse.getAmount().getTotal();
        String tradeType = parse.getTradeType().name();
        PayRecordBo.create(userId,orderId,amount,tradeType);
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/19 15:38
     * 将支付结果下发小程序
     *
     */
    private void payNoticeMessage(Transaction parse,String orderId){
        MemberOrderDetailEntity detail = OrderDetailBo.getByOrderId(orderId);
        LockNotifyMessageService service = SpringUtil.getBean(LockNotifyMessageService.class);
        LockNotifyMessageDTO dto = new LockNotifyMessageDTO();
        dto.setLockId(detail.getDeviceId());
        dto.setMessageParams(buildParse(parse));
        service.dealPayResultNotifyMessage(dto);
    }

    private String buildParse(Transaction parse){
        parse.setMchid(null);
        parse.setAppid(null);
        parse.setBankType(null);
        parse.setBankType(null);
        parse.setAttach(null);
        return JSON.toJSONString(parse);
    }
}

bo:

import com.smart.iot.gmt.app.annotation.SpringUtil;
import com.smart.iot.gmt.app.entity.PayRecordEntity;
import com.smart.iot.gmt.app.service.pay.wechat.PayInfoConfig;
import com.smart.iot.gmt.app.service.pay.wechat.WXPayUtil;
import com.smart.iot.util.StringUtil;
import com.wechat.pay.java.core.Config;
import com.wechat.pay.java.core.RSAAutoCertificateConfig;
import com.wechat.pay.java.core.exception.ServiceException;
import com.wechat.pay.java.core.exception.ValidationException;
import com.wechat.pay.java.core.notification.NotificationConfig;
import com.wechat.pay.java.core.notification.NotificationParser;
import com.wechat.pay.java.core.notification.RequestParam;
import com.wechat.pay.java.service.payments.jsapi.JsapiService;
import com.wechat.pay.java.service.payments.jsapi.model.*;
import com.wechat.pay.java.service.payments.model.Transaction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static com.wechat.pay.java.core.http.Constant.*;

/**
 *
 * @author Rick chou
 * @date 2024/7/16 9:10
 * 微信支付BO
 *
 */
@Slf4j
@Component
public class WechatPayBo extends PayRecordEntity {

    private static PayInfoConfig getConfig(){
        PayInfoConfig payInfoConfig = SpringUtil.getBean(PayInfoConfig.class);
        return payInfoConfig;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 9:35
     * 构建支付请求SERVICE
     *
     */
    public static JsapiService getService(){
        PayInfoConfig payInfoConfig = getConfig();
        Config config = new RSAAutoCertificateConfig.Builder()
            .merchantId(payInfoConfig.getMchId())
            .privateKeyFromPath(payInfoConfig.getKeyPath())
            .merchantSerialNumber(payInfoConfig.getMchSerialNo())
            .apiV3Key(payInfoConfig.getApiKey())
            .build();
        JsapiService service = new JsapiService.Builder().config(config).build();
        return service;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 10:31
     * 构造NOTIFY_CONFIG
     *
     */
    private static NotificationConfig buildNotifyConfig(){
        PayInfoConfig payInfoConfig = getConfig();
        NotificationConfig config = new RSAAutoCertificateConfig.Builder()
                .merchantId(payInfoConfig.getMchId())
                .privateKeyFromPath(payInfoConfig.getKeyPath())
                .merchantSerialNumber(payInfoConfig.getMchSerialNo())
                .apiV3Key(payInfoConfig.getApiKey())
                .build();
        return config;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 9:35
     * 构建支付请求参数
     *
     */
    private static PrepayRequest buildParam(Integer price, String orderId, String userId){
        PayInfoConfig payInfoConfig = getConfig();
        PrepayRequest prepayRequest = new PrepayRequest();
        Amount amount = new Amount();
        amount.setTotal(price);
        prepayRequest.setAmount(amount);
        prepayRequest.setAppid(payInfoConfig.getAppId());
        prepayRequest.setMchid(payInfoConfig.getMchId());
        prepayRequest.setNotifyUrl(payInfoConfig.getNotifyUrl());				// 回调接口地址
        prepayRequest.setDescription("微信支付");
        prepayRequest.setOutTradeNo(orderId);       // 订单号
        prepayRequest.setAttach("member");                                     // 订单类型(回调时可根据这个数据辨别订单类型或其他)

        //根据token拿到openid,指定该预支付订单的支付者身份
        Payer payer = new Payer();
        payer.setOpenid(WeixinUserBo.getOpenId(userId));
        prepayRequest.setPayer(payer);
        return prepayRequest;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 9:53
     * 解析支付结果
     *
     */
    private static Map<String,Object> parsePay(PrepayResponse response){
        PayInfoConfig payInfoConfig = getConfig();
        Map<String, Object> params = new HashMap<>();
        Long timeStamp = System.currentTimeMillis() / 1000;
        String substring = UUID.randomUUID().toString().replaceAll("-", "").substring(0, 32);
        String signatureStr = Stream.of(
                payInfoConfig.getAppId(),
                String.valueOf(timeStamp),
                substring,
                "prepay_id=" + response.getPrepayId()
        ).collect(Collectors.joining("\n", "", "\n"));
        String sign = WXPayUtil.getSign(signatureStr, payInfoConfig.getKeyPath());
        params.put("timeStamp", String.valueOf(timeStamp));
        params.put("nonceStr", substring);
        params.put("paySign", sign);
        params.put("signType", "RSA");
        params.put("package", "prepay_id=" + response.getPrepayId());
        return params;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 10:33
     * 解析回调结果
     *
     */
    private static RequestParam parseNotify(HttpServletRequest request)throws IOException {
        String data = StringUtil.getStringForInput(request.getInputStream());
        String timestamp = request.getHeader(WECHAT_PAY_TIMESTAMP);
        String nonce = request.getHeader(WECHAT_PAY_NONCE);
        String signType = request.getHeader("Wechatpay-Signature-Type");
        String serialNo = request.getHeader(WECHAT_PAY_SERIAL);
        String signature = request.getHeader(WECHAT_PAY_SIGNATURE);

        RequestParam requestParam = new RequestParam.Builder()
                .serialNumber(serialNo)
                .nonce(nonce)
                .signature(signature)
                .timestamp(timestamp)
                .signType(signType)         // 若未设置signType,默认值为 WECHATPAY2-SHA256-RSA2048
                .body(data)
                .build();
        return requestParam;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 9:47
     * 调起支付
     *
     */
    public static Map<String, Object> payment(Integer price, String orderId, String userId){
        JsapiService service = getService();
        PrepayRequest prepayRequest = buildParam(price, orderId, userId);
        PrepayResponse response = service.prepay(prepayRequest);
        Map<String, Object> result = parsePay(response);
        result.put("orderId",orderId);
        return result;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 10:16
     * 支付回调
     *
     */
    public static Transaction payNotify(HttpServletRequest request) throws Exception {
        NotificationConfig config = buildNotifyConfig();
        NotificationParser parser = new NotificationParser(config);
        RequestParam requestParam = parseNotify(request);
        Transaction parse = null;
        try {
             parse = parser.parse(requestParam, Transaction.class);
        }catch (ValidationException e){
            log.error("sign verification failed", e);
        }
        return parse;
    }

    /**
     *
     * @author Rick chou
     * @date 2024/7/16 11:17
     * 查询订单
     *
     */
    public static Transaction queryPayOrder(String orderId) {
        PayInfoConfig payInfoConfig = getConfig();
        JsapiService service = getService();
        QueryOrderByOutTradeNoRequest queryRequest = new QueryOrderByOutTradeNoRequest();
        queryRequest.setMchid(payInfoConfig.getMchId());
        queryRequest.setOutTradeNo(orderId);
        Transaction parse = null;
        try {
            parse = service.queryOrderByOutTradeNo(queryRequest);
        }catch (ServiceException e){
            log.info("code=[%s], message=[%s]\n", e.getErrorCode(), e.getErrorMessage());
            log.info("reponse body=[%s]\n", e.getResponseBody());
        }
        return parse;
    }
}

PayInfoConfig

import lombok.Data;
import lombok.ToString;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@ToString
@Component
@ConfigurationProperties(prefix = "wx")
public class PayInfoConfig {

    //小程序appid
    private String appId;
    //商户号
    private String mchId;
    //证书序列号
    private String mchSerialNo;
    //小程序秘钥
    private String appSecret;
    //api秘钥
    private String apiKey;
    //回调接口地址
    private String notifyUrl;
    //证书地址
    private String keyPath;
}

上述的PayInfoConfig中的参数第二、三、五、七个参数去商户号后台获取。

三.补充说明

在实际的支付开发中需要注意一些比较重要的点,假设你现在做的是一个会员开通功能。

1.在你点击开通的时候,你需要做的肯定是调用你自己的后台业务接口生成一个会员订单,同时调用微信支付获取支付参数返回到前端。这样用户看到的就是直接拉起支付。

2.当你执行支付操作后你的支付回调接口会收到支付结果,这个时候你服务端要主动通知小程序,并且当小程序拉起支付后要定时调用支付查询接口来主动查询支付完成支付。做个双保险比较好。

3.微信支付完成后有个"完成"按钮,点击后就会回到wx.requestPayment的success回调里,这里最好也要查询下订单状态。

4.还有点我还没怎么做处理,也是个题外话,就是当支付回调时服务器挂了咋整,得想个万全之策,这个就交给你们解答了。

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

低代码与人工智能的融合:加速应用开发的未来趋势

什么是低代码&#xff0c;它是如何工作的&#xff1f; 低代码是一种软件开发概念&#xff0c;它通过最小化手工编码的方式&#xff0c;为开发和部署定制化应用提速。低代码平台具备模型驱动、沙盒多环境、可编程的可视化开发方式等&#xff0c;能用于开发包含有用户界面、业务逻…

二叉树——链式结构的实现

首先是分为三个文件进行实现&#xff1a;tree.h、tree.c、test.c tree.h 用链表来表示⼀棵⼆叉树&#xff0c;即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成&#xff0c;数据域和左右指针域&#xff0c;左右指针分别用来给出该结点左孩⼦和右孩⼦所在…

基于Springboot + vue + mysql 校友社交管理系统 设计实现

目录 &#x1f4da; 前言 &#x1f4d1;摘要 1.1 研究背景 &#x1f4d1;操作流程 &#x1f4da; 系统架构设计 &#x1f4da; 数据库设计 &#x1f4ac; E-R表 4.2.2数据库逻辑结构设计 &#x1f4da; 系统功能的具体实现 系统功能模块 系统首页 校友会信息 校友活动 …

仿RabbitMQ实现消息队列———整体框架

目录 一、项目简介 需求分析 AMQP 特点&#xff1a; AMQP 模型&#xff1a; 交换机类型 持久化 网络通信 二、服务端模块 1、交换机数据管理 2、队列数据管理 3、绑定数据管理 4、消息数据管理 5、虚拟机数据管理 6、路由匹配管理 7、消费者管理 8、信道管理 …

智源发布三款BGE新模型,再次刷新向量检索最佳水平

近期&#xff0c;以大语言模型&#xff08;LLM&#xff09;为基础的向量模型&#xff08;embedding model&#xff09;变得愈发流行。得益于大语言模型强大的语义理解能力&#xff0c;相关模型在下游任务中的检索精度得到了显著的提升。然而&#xff0c;当前基于大模型的向量模…

leetcode 1555 银行账号概要(postgresql)

需求 用户表&#xff1a; Users --------------------- | Column Name | Type | --------------------- | user_id | int | | user_name | varchar | | credit | int | --------------------- user_id 是这个表的主键。 表中的每一列包含每一个用户当前的额度信息。 交易表&…

Nginx反向代理实战

使用反向代理代理服务 假设我们有三台服务器提供不同的服务 nginx作为代理服务器 代理服务器&#xff1a; 192.168.101.23 其余三台服务器 服务器1 192.168.101.18 服务器2 192.168.101.87 服务器3 192.168.101.20 代理服务器的nginix配置 server {listen 8085;ser…

【机器学习基础】机器学习概述与实践基础

【作者主页】Francek Chen 【专栏介绍】 ⌈ ⌈ ⌈Python机器学习 ⌋ ⌋ ⌋ 机器学习是一门人工智能的分支学科&#xff0c;通过算法和模型让计算机从数据中学习&#xff0c;进行模型训练和优化&#xff0c;做出预测、分类和决策支持。Python成为机器学习的首选语言&#xff0c;…

Docker中使用自定义网络方式实现Redis集群部署与测试流程

场景 Docker中Docker网络-理解Docker0与自定义网络的使用示例&#xff1a; Docker中Docker网络-理解Docker0与自定义网络的使用示例-CSDN博客 参考上面的流程实现自定义网络的实现。 下面记录其应用实例&#xff0c;使用Docker的自定义网络实现redis集群部署。 注&#xf…

IP地址https证书的优势与申请途径

一、IP地址SSL证书的优势 无需域名&#xff1a;对于一些内部系统或者专用设备而言&#xff0c;它们可能不具有域名&#xff0c;但仍需保障通信安全。IP地址SSL证书正好满足这一需求。简化管理&#xff1a;对于拥有大量设备的企业来说&#xff0c;维护每个设备的域名可能是一个…

tomato-靶机渗透

tomato-靶机 一、安装靶机环境 下载双击.ova文件&#xff0c;写文件名路径导入 打开虚拟机用NAT模式 编辑–>虚拟网络编辑器查看IP段 二、信息收集 1.御剑端口扫描查找该虚拟机的IP 访问网站 扫目录 dirb http://192.168.30.130 收集到目录 /server-status /antibot_im…

成为git砖家(9): git checkout <commit> <file> 的含义

文章目录 1. 目的2. 官方文档解释3. Tower 的解释4. References 1. 目的 git checkout 命令承载了非常多的功能&#xff0c; 想要一次全弄懂&#xff0c;不太现实&#xff1b; 这次白鱼带领大家学习 git checkout <file> 的用法。 老规矩&#xff0c;先查看 git checko…

鸿蒙 HarmonyOS NEXT端云一体化开发-云数据库篇

一、概述 云数据库是一款基于对象模型的数据库&#xff0c;采用存储区、对象类型和对象三级结构。 数据模型 存储区 存储区是一个独立的数据存储区域&#xff0c;多个数据存储区之间相互独立&#xff0c;每个存储区拥有完全相同的对象类型定义 --类似于关系型数据库中的da…

如何有效管理众多账号密码:选择适合你的密码管理工具

在如今的数字化时代&#xff0c;我们的生活几乎离不开各种互联网应用和服务。从社交媒体到在线银行&#xff0c;从购物网站到工作平台&#xff0c;每个应用都要求我们注册账号并设置密码。 随着账号数量的不断增加&#xff0c;管理这些密码成为了一个令人头疼的问题。幸运的是…

AMEYA360:上海雷卯电子CAN BUS芯片静电浪涌击穿整改方案

在现代电子系统中&#xff0c;CAN Bus(Controller Area Network Bus&#xff0c;控制器局域网络总线)作为一种常用的通信协议&#xff0c;标准CAN通常指的是CAN 2.0A和CAN 2.0B协议&#xff0c;其最大通讯速率为1Mbps。而高速CAN通常指的是CAN FD(CAN Flexible Data-rate)协议&…

如何磁盘覆写

使用命令提示符写0 命令提示符是Windows系统内置的一个非常实用的工具&#xff0c;可以通过几行短短的命令来完成各种各样的电脑相关操作而无需开启应用程序&#xff0c;所以我们可以通过命令提示符中的format命令来完成硬盘写0任务。 步骤1. 在搜索框中输入cmd并以管理员身份…

每日一题系列-两个数组的交集

&#x1f308;个人主页&#xff1a;羽晨同学 &#x1f4ab;个人格言:“成为自己未来的主人~” class Solution { public:int hash[1010] {0};vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {vector<int> ret;for(a…

漏洞复现-路由器TOTOLINK-A6000R-RCE

本文来自无问社区&#xff0c;更多漏洞信息可前往查看http://wwlib.cn/index.php/artread/artid/14996.html 0x01 产品简介 TOTOLINK A6000R是一款性能卓越的无线路由器&#xff0c;采用先进的技术和设计&#xff0c;为用户提供出色的网络体验。其支持最新的Wi-Fi标准&#x…

Java学习----类和对象与封装

目录 一、面向对象和面向过程二、类类的定义类的实例化this引用&#xff08;这一块一定要看懂哦&#xff09;类的构造方法成员变量的初始化 三、封装包常见的包 四、关于static初始化 五、代码块六、对象的打印--toString 一、面向对象和面向过程 众所周知&#xff0c;Java语言…

HomeServer平台选择,介绍常用功能

​​ 平台选择 HomeServer 的性能要求不高&#xff0c;以下是我的硬件参数&#xff0c;可供参考&#xff1a; ‍ 硬件&#xff1a; 平台&#xff1a;旧笔记本CPU&#xff1a;i5 4210u内存 8G硬盘&#xff1a;128G 固态做系统盘&#xff0c;1T1T 机械盘组 RAID1 做存储。硬…