大数据互联网架构阶段 前台系统架构 跨域请求

最新推荐文章于 2022-11-24 17:05:56 发布
最新推荐文章于 2022-11-24 17:05:56 发布
阅读量685 收藏 1
点赞数
分类专栏： 大数据 WEB 文章标签： 大数据 数据库 系统架构 互联网 架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chou_out_man/article/details/79243993
版权

电商项目 前台系统的架构

零、目录

  • 前台架构设计
  • 前台分类树
  • 跨域请求技术
    • jsonp
    • httpClient

一 、前台架构设计

  1. 不能直接访问数据库 ， 需要通过后台访问数据
  2. 架构： 单通道连接资源 ， 数据资源不能交叉访问
  3. 安全： 前台 对外网挂接 ， 不适合访问数据库 ， 有安全隐患 ， 前台需要跨系统访问数据
  4. 跨系统访问数据用到的的技术：
    1. jsonp
    2. httpClient
    3. RabbitMQ

二、 前台分类树

  1. 商品分类：
    1. 在后台系统中的商品分类请求的设计是分级请求的 ， 先展示一级分类 ，然后点击时获取被点击的id ， 获取他的子分类
    2. 但是在前台系统商品分类的设计中 ， 只发起一次ajax异步请求 ， 请求到所有的封装好的三层结构的商品分类数据（使用map+ list+ 三层循环嵌套实现）
  2. 商品分类数据的结构

  3. 数据的要求

    1. 前台需要一个json串 ， ,需要构建一个对象ItemCatResult,内部只有一个data属性的集合
    2. 整体的返回结构都在data中完成

    3. 每个data中的list对象进行封装嵌套完成3层结构

      u, n, i;
其中u和n都是字符串
i是list集合,集合的元素类型又是itemCatData

    4. 按照以上要求完成pojo设计

      public class ItemCatResult {
    @JsonProperty("data")
    private List<ItemCatData> itemCats ;

    public List<ItemCatData> getItemCats() {
        return itemCats;
    }

    public void setItemCats(List<ItemCatData> itemCats) {
        this.itemCats = itemCats;
    }

} 

public class ItemCatData {

    @JsonProperty("u")//传递时以u传递 ， 减少跨域传递数据的字节数 ， 加快传递速度
    private String url;
    @JsonProperty("n")
    private String name;
    @JsonProperty("i")
    private List<?> items;
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<?> getItems() {
        return items;
    }
    public void setItems(List<?> items) {
        this.items = items;
    }


}
完成三成结构数据的封装
处理前台分类树 请求，返回具有三层结构偶的数据
    @RequestMapping("web/itemcat/all")
    @ResponseBody
    public ItemCatResult queryItemCat() {
        //整理三层结构的数据
        //先获取所有的数据
        List<ItemCat> itemCats = itemCatService.queryAll();
        //创建一个返回对象
        ItemCatResult result = new ItemCatResult();
        //引入一个map + list + 三层for循环嵌套
        //map维护当前分类中的父子关系，  key保存一个id ， value保存该id的所有子类（list形式）
        Map<Long , List<ItemCat>> map  = new HashMap<Long , List<ItemCat>>();
        //对map进行处理
        for(ItemCat itemCat : itemCats) {
            //从当前的所有list中获取一个parentId
            if(!map.containsKey(itemCat.getParentId())) {
                //创建一个map的元素 ，key为整个parentId ， value为该id的所有子类（list形式）
                map.put(itemCat.getParentId(), new ArrayList<ItemCat>());
            }
            //把当前对象放入map维护的父子关系中 。 
            map.get(itemCat.getParentId()).add(itemCat);
        }
        //开始构建result对象
        //一级菜单内容 ， 从map获取一级分类的list
        List<ItemCat> itemCatList01 = map.get(new Long(0));
        //从一级菜单入手完成result的data
        List<ItemCatData> itemCatDataList1 = new ArrayList<ItemCatData>();
        //完成data里的数据
        for(ItemCat itemCat : itemCatList01) {
            ItemCatData itemCatData1 = new ItemCatData();
            itemCatData1.setUrl("/products/"+itemCat.getId()+".html");
            itemCatData1.setName("<a href='"+itemCatData1.getUrl()+"'>"+itemCat.getName()+"</a>");
            //进行当前对象的二层菜单的数据封装个 ， 使用第二层for
            List<ItemCatData> itemCatDataList2 = new ArrayList<ItemCatData>();
            List<ItemCat> itemCatList02 = map.get(itemCat.getId());
            for(ItemCat itemCats2 : itemCatList02) {
                ItemCatData itemCatData2 = new ItemCatData();
                itemCatData2.setUrl("/products/"+itemCats2.getId()+".html");
                itemCatData2.setName("<a href='"+itemCatData2.getUrl()+"'>"+itemCats2.getName()+"</a>");

                List<String> itemCatDataList3 = new ArrayList<String>();
                List<ItemCat> itemCatList03 = map.get(itemCats2.getId());
                for(ItemCat itemCat3 : itemCatList03) {
                    itemCatDataList3.add("/products/"+itemCat3.getId()+".html"+itemCat3.getName());
                }
                itemCatData2.setItems(itemCatDataList3);
                itemCatDataList2.add(itemCatData2);
            }
            itemCatData1.setItems(itemCatDataList2);
            itemCatDataList1.add(itemCatData1);
        }

        result.setItemCats(itemCatDataList1);

        return result;
    }

三 、 跨域请求问题

  1. 在电商项目中 ， 为了提高数据库的可用性 ， 引入了缓存技术 ， 而像电商项目这样的大型项目一般都需需要进行横向拆分成多个特定功能的系统来同时开发 ， 但是由于多个系统去访问数据库执行魂村逻辑时， 可能引起数据混乱 ， 这就限制了数据只能单通道访问 ， 前台系统在缓存中没有数据时不能直接访问数据库 ， 而是通过后台系统去请求数据 。 ， 这就引出了跨域访问的种种问题 。

四、 Jsonp跨域请求数据

  1. 前台系统的页面发出ajax请求 ， 到后台系统请求商品分类数据
  2. 但是前台和后台是两个系统 ， 从后台访问数据属于跨域访问 ， 无法使用json格式数据 ， 需要jsonp

  3. 前台调用的jquery代码

    $.getJSONP(url  ， 参数){}
  4. json广泛流行的原因是 ， json是js原声支持的格式， 在js中可以自动将json格式的数据转换为对象后调用其中的属性 。
  5. 但是由于js的同源策略导致前台系统获取到后台系统的数据后不能够解析 ， 想要解决js同源策略引起的跨域请求问题 ， 需要引入jsonp技术
  6. jsonp实际上就是在json字符串外包装一个方法 ， 利用script标签可以将跨域的数据请求到 ， 然后通过一个js方法即可解析 ， 但是要注意js的方法名必须要与json外层包装的方法名一致
  7. 但是后台通过@ResponseBody返回的数据默认就是json格式 ， 需要自己构建一个responseBody类似的对象将返回的数据转换成jsonp需要的格式 。

  8. 开发步骤：

    1. 前台发出请求 url？callback=xxxx
    2. 后台controller处理这个请求时不接受callback参数 ， 正常返回数据即可

    3. 自定义responseBody转换器

          public class CallbackMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {

        // 做jsonp的支持的标识，在请求参数中加该参数
        private String callbackName;

        @Override
        protected void writeInternal(Object object, HttpOutputMessage outputMessage) throws IOException,
                HttpMessageNotWritableException {
            // 从threadLocal中获取当前的Request对象
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder
                    .currentRequestAttributes()).getRequest();
            String callbackParam = request.getParameter(callbackName);
            if (StringUtils.isEmpty(callbackParam)) {
                // 没有找到callback参数，直接返回json数据
                super.writeInternal(object, outputMessage);
            } else {
                JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
                try {
                    //将对象转换为json串，然后用回调方法包括起来
                    String result = callbackParam + "(" + super.getObjectMapper().writeValueAsString(object)
                            + ");";
                    IOUtils.write(result, outputMessage.getBody(), encoding.getJavaName());
                } catch (JsonProcessingException ex) {
                    throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
                }
            }

        }

        public String getCallbackName() {
            return callbackName;
        }

        public void setCallbackName(String callbackName) {
            this.callbackName = callbackName;
        }

    }

    4. 将自定义的转换器配置在spring-mvc配置文件中

      <!-- MVC注解驱动 -->
    <mvc:annotation-driven>
        <!-- 采用自定义方案 -->
        <mvc:message-converters>
            <!-- 定义原有的文本转化器  ， 如果不定义 则会被后定义的文本转换器覆盖-->
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg index="0" value="UTF-8" />
            </bean>

            <!-- 添加自定义json转化器，完成jsonp格式数据的峰装 ， 支持json跨域 -->
            <bean
                class="com.jt.common.spring.exetend.jackson.CallbackMappingJackson2HttpMessageConverter">
                <!-- 跨域请求中的请求参数名 --><!-- 当参数中有callback属性时 ， 调用这个转换器 -->
                <!-- 从参数中寻找callback ， 在代码中处理 -->
                <property name="callbackName" value="callback"></property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    5. 这样在返回就过时 ， 就会在结果外层包装一个callback参数对应的方法 ， 形成jsonp格式的数据 。

四、 httpClient跨域请求

  1. 自定义httpClientService

    @Service
public class HttpClientService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientService.class);

    @Autowired(required=false)
    private CloseableHttpClient httpClient;

    @Autowired(required=false)
    private RequestConfig requestConfig;

    /**
     * 执行get请求
     * 
     * @param url
     * @return
     * @throws Exception
     */
    public String doGet(String url,Map<String, String> params,String encode) throws Exception {
        LOGGER.info("执行GET请求，URL = {}", url);
        if(null != params){
            URIBuilder builder = new URIBuilder(url);
            for (Map.Entry<String, String> entry : params.entrySet()) {
                builder.setParameter(entry.getKey(), entry.getValue());
            }
            url = builder.build().toString();
        }
        // 创建http GET请求
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(requestConfig);
        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpClient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                if(encode == null){
                    encode = "UTF-8";
                }
                return EntityUtils.toString(response.getEntity(), encode);
            }
        } finally {
            if (response != null) {
                response.close();
            }
            // 此处不能关闭httpClient，如果关闭httpClient，连接池也会销毁
        }
        return null;
    }

    public String doGet(String url, String encode) throws Exception{
        return this.doGet(url, null, encode);
    }

    public String doGet(String url) throws Exception{
        return this.doGet(url, null, null);
    }

    /**
     * 带参数的get请求
     * 
     * @param url
     * @param params
     * @return
     * @throws Exception
     */
    public String doGet(String url, Map<String, String> params) throws Exception {
        return this.doGet(url, params, null);
    }

    /**
     * 执行POST请求
     * 
     * @param url
     * @param params
     * @return
     * @throws Exception
     */
    public String doPost(String url, Map<String, String> params,String encode) throws Exception {
        // 创建http POST请求
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(requestConfig);

        if (null != params) {
            // 设置2个post参数，一个是scope、一个是q
            List<NameValuePair> parameters = new ArrayList<NameValuePair>(0);
            for (Map.Entry<String, String> entry : params.entrySet()) {
                parameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }

            // 构造一个form表单式的实体
            UrlEncodedFormEntity formEntity = null;
            if(encode!=null){
                formEntity = new UrlEncodedFormEntity(parameters,encode);
            }else{
                formEntity = new UrlEncodedFormEntity(parameters);
            }
            // 将请求实体设置到httpPost对象中
            httpPost.setEntity(formEntity);
        }

        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpClient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                return EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } finally {
            if (response != null) {
                response.close();
            }
        }
        return null;
    }


    /**
     * 执行POST请求
     * 
     * @param url
     * @param params
     * @return
     * @throws Exception
     */
    public String doPost(String url, Map<String, String> params) throws Exception {
        // 创建http POST请求
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(requestConfig);

        if (null != params) {
            // 设置2个post参数，一个是scope、一个是q
            List<NameValuePair> parameters = new ArrayList<NameValuePair>(0);
            for (Map.Entry<String, String> entry : params.entrySet()) {
                parameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }

            // 构造一个form表单式的实体
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters);
            // 将请求实体设置到httpPost对象中
            httpPost.setEntity(formEntity);
        }

        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpClient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                return EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } finally {
            if (response != null) {
                response.close();
            }
        }
        return null;
    }

    public String doPostJson(String url, String json) throws Exception {
        // 创建http POST请求
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(requestConfig);

        if(null != json){
            //设置请求体为 字符串
            StringEntity stringEntity = new StringEntity(json,"UTF-8");
            httpPost.setEntity(stringEntity);
        }

        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpClient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                return EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } finally {
            if (response != null) {
                response.close();
            }
        }
        return null;
    }

}

  2. 在spring配置文件中配置

    <!-- 定义httpclient连接池 -->
<bean id="httpClientConnectionManager" class="org.apache.http.impl.conn.PoolingHttpClientConnectionManager" destroy-method="close">
    <!-- 设置连接总数 -->
    <property name="maxTotal" value="${http.pool.maxTotal}"></property>
    <!-- 设置每个地址的并发数 -->
    <property name="defaultMaxPerRoute" value="${http.pool.defaultMaxPerRoute}"></property>
</bean>

<!-- 定义 HttpClient工厂，这里使用HttpClientBuilder构建-->
<bean id="httpClientBuilder" class="org.apache.http.impl.client.HttpClientBuilder" factory-method="create">
    <property name="connectionManager" ref="httpClientConnectionManager"></property>
</bean>

<!-- 得到httpClient的实例 -->
<bean id="httpClient" factory-bean="httpClientBuilder" factory-method="build"/>

<!-- 定期清理无效的连接 -->
<bean class="com.jt.common.util.IdleConnectionEvictor" destroy-method="shutdown">
    <constructor-arg index="0" ref="httpClientConnectionManager" />
    <!-- 间隔一分钟清理一次 -->
    <constructor-arg index="1" value="60000" />
</bean>

<!-- 定义requestConfig的工厂 -->
<bean id="requestConfigBuilder" class="org.apache.http.client.config.RequestConfig.Builder">
    <!-- 从连接池中获取到连接的最长时间 -->
    <property name="connectionRequestTimeout" value="${http.request.connectionRequestTimeout}"/>
    <!-- 创建连接的最长时间 -->
    <property name="connectTimeout" value="${http.request.connectTimeout}"/>
    <!-- 数据传输的最长时间 -->
    <property name="socketTimeout" value="${http.request.socketTimeout}"/>
    <!-- 提交请求前测试连接是否可用 -->
    <property name="staleConnectionCheckEnabled" value="${http.request.staleConnectionCheckEnabled}"/>
</bean> 

<!-- 得到requestConfig实例 -->
<bean id="requestConfig" factory-bean="requestConfigBuilder" factory-method="build" />

  3. 配置文件所需要的参数信息 httpclient.properties

        #从连接池中获取到连接的最长时间
    http.request.connectionRequestTimeout=500
    #5000
    http.request.connectTimeout=5000
    #数据传输的最长时间
    http.request.socketTimeout=30000
    #提交请求前测试连接是否可用
    http.request.staleConnectionCheckEnabled=true

    #设置连接总数
    http.pool.maxTotal=200
    #设置每个地址的并发数
    http.pool.defaultMaxPerRoute=100
chou_out_man
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
终于有人把前台、中台、后台都讲明白了
大数据
11-18 3104
导读：很多人提到中台时自然会问：“既然有中台，那是否有前台和后台？它们各自的职责又是什么呢？”本文为你详细解答。作者：欧创新 邓頔来源：大数据DT（ID：hzdashuju）我们来看一下...
前台会员系统架构
AlaGeek的博客
08-16 3138
1、项目架构图 前台会员系统架构为分布式服务架构，不像后台管理系统的单一架构，所有功能都放在一起，按前端页面展示和后端业务逻辑划分层次。前台会员系统按照功能的类型划分工程模块，其架构图如下： 2、架构详情 在分布式微服务中，功能被抽象成多个微服务，微服务之间只允许通过接口进行访问。为了使得微服务之间能互相找到对方，需要将所有微服务都注册到注册中心里。 在本架构中，微服务总共分成两大类，一类为数据中心，一类为业务逻辑相关的微服务。 i、数据中心 数据中心中包含有两个微服务， 所有与关系型数据库MySQL相
关于跨域的一些知识
weixin_30407613的博客
03-02 147
由于公司最近要做一个跨域的项目，所以研究了一个跨域，并实践了其中的几中方法。这理总结一下。 ==========================跨域-知识=========================== 什么是跨域？ 首先什么是跨域，简单地理解就是因为JavaScript同源策略的限制。 什么是同源策略？ 在客户端编程语言中，如JavaScrip...
适合大数据的前台模板
12-12
适合大数据的前台模板,在网上搜集的,适合大数据的前台模板,在网上搜集的,
《大数据》专题征文：跨域数据管理（截稿日期：2023年2月28日）
最新发布
weixin_45585364的博客
11-24 367
跨域数据管理是指伴随着数字经济时代数据要素流通的大趋势，以及算力网络等全国范围内广域基础设施的完善，数据管理正在从面向和限定于单域的孤立服务，发展到跨越空间域、信任域和管辖域的数据共享与协同服务的新阶段。跨域数据管理能够打破“数据孤岛”，促进数据要素的共享与协同，促进数据价值的最大化。跨域为数据管理带来了全新的挑战，例如在通信层面，面临跨空间域的挑战，体现为不确定性网络下的分布式事务、分布式共识等...
关于前段js大数据量提交跨域数据时…
ZHANGHUI3239619的专栏
12-07 864
* isProxy：使用说明   *   * JSONP可解决跨越的问题，但是解决不了跨域时大数据量提交的问题。   *   * 如果跨域并且存在大数据量的可能性，那么就需要使用代理包了。isProxy:true   *   * 非跨域时不存在大数据量提交的问题 。 jQuery.ajax({                    type: "post",                   
2022大数据存储架构实践资料合集-共51份.zip
04-01
2022大数据存储架构实践资料合集，共51份。 一站式海量数据集成框架原理和实践 为云而生的分布式文件系统 未来数据库需要关心的硬核创新 Apache Doris存储层向量化改造设计与实现 数据编排技术在联通的应用 基于云...
DataFunSummit：2022年大数据存储架构峰会PPT合集（52份）.zip
06-17
DataFunSummit：2022年大数据存储架构峰会PPT合集（52份）。 JuiceFS-为云而生的分布式文件系统 未来数据库需要关心的硬核创新 云原生开源分布式存储CubeFS在数据湖的探索与实践 数据编排技术的应用 基于云上对象...
跨域SSO的实现之一：架构设计
03-02
他说你们现在帮我们公司做了很多的ASP.NET的网站和忽悠我们上线的各种系统，现在我想要我的客户只要在我们拥有的任何一个网站上登录一次，那么在我所有的网站上该用户就都已经登录了，同样，随便他从哪个网站上注销...
ajax前台后台跨域请求处理方式
08-28
Ajax跨域请求是Web开发中常见的问题，特别是在前后端分离的架构下，由于浏览器的同源策略限制，JavaScript发起的HTTP请求通常只能访问与当前页面同源（协议、域名和端口都相同）的资源。但有时我们需要从不同源获取...
jquery使用$.getJson()跨域大数据量请求方法
gdpencil的专栏
03-18 7396
jq的$.get和$.post方法，都是不能跨域访问的。$.getJson却让我们看到了希望的曙光， 不过有一点不足的是，这个是GET的方法，传递的参数是有限制的，最大不超过2083个字符。 但问题终有解决办法的，经分析得出解决方案如下： a.com使用$.getJson向b.com发送请求，在请求的同时，a.com把需要的传递的内容放到临时文件中(或者membercache)， b.com收到请求，反过来向a.com请求需要的数据，进行必要的操作，再给a.com返回成功的信息。这样就达到跨域大数据
基于“大中台+小前台”思想的电商系统总体架构设计
一个有情怀的程序猿博客
08-06 5959
一、架构总原则 1. 大中台+小前台的架构思路 2. 业务中台采用领域驱动设计（DDD），在其上构建业务能力SAAS，持续不断进行迭代演进。 3. 平台化定位，进行了业务隔离设计，方便一套系统支撑不同玩法的业务类型和便于定制化扩展。 4. 前后端分离，通过服务接入层进行路由适配转发。 5. 天然的分库分表，消息解耦和分布式缓存设计，支持弹性扩容，以支持大数据高并发场景。 二、系统逻辑架构图...
实现跨域网络访问
weixin_38378596的博客
09-29 934
实现跨域网络访问基本说明在前端开发中，我们可以使用ajax来发送网络请求。 发送请求的方式：GET请求|POST请求 发送请求的主要步骤： GET请求： 1）创建请求对象（XMLHTTPRequest）注意兼容性问题 2）设置请求方法和路径（open方法） 3）发送请求（send方法） 4）监听网络请求的状态（onreadystateschange） 5）处理
大数据如何在前端流畅展示
热门推荐
ken_ding的博客
01-22 1万+
如果要在前端呈现大量的数据，一般的策略就是分页。前端要呈现百万数据，这个需求是很少见的，但是展示千条稍微复杂点的数据，这种需求还是比较常见，只要内存够，javascript 肯定是吃得消的，计算几千上万条数据，js 效率根本不在话下，但是 DOM 的渲染浏览器扛不住，CPU 稍微搓点的电脑必然会卡爆。 策略：显示三屏数据，其他的移除 DOM。 一、 策略 下面是我简单勾画的一个草图，我们把一串数据...
dhtml xgrid 实现前台大数据延迟加载效果
mememama111的专栏
03-18 171
  !DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;Smart Rendering&lt;/title&gt; &lt;/head&gt; &lt;body&gt; &lt;link rel=
大数据平台：架构、定位与增值策略
大数据平台目标架构及定位主要探讨了在现代信息技术环境下，构建和管理大数据平台的关键要素及其战略部署。该方案的核心关注点在于如何通过高效的架构设计和技术创新，满足大数据时代的挑战与机遇。 一、大数据平台...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值