韵搜坊 -- 聚合接口优化(设计模式)

最新推荐文章于 2024-05-31 23:44:53 发布
最新推荐文章于 2024-05-31 23:44:53 发布
阅读量1.2k 收藏 16
点赞数 36
分类专栏： 韵搜坊（全栈开发） 文章标签： 设计模式 vue.js 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74870396/article/details/139011645
版权

文章目录

门面模式

帮助我们用户（客户端）去更轻松的实现功能，不需要关心门面背后的细节，当调用你接口的客户端觉得麻烦的时候，是不是就可以抽象成一个门面了？
后端
将controller层的业务代码抽象到manager/SearchFacade中
前端
IndexPage代码改造为加载单类数据

<template>
  <div class="index-page">
  <a-input-search
      v-model:value="searchText"
      placeholder="input search text"
      enter-button
      @search="onSearch"
    />
        <MyDivider/>
      <a-tabs v-model:activeKey="activeKey" @change="onTabChange">
    <a-tab-pane key="post" tab="文章" > <PostList :post-list="postList"/></a-tab-pane>
    <a-tab-pane key="picture" tab="图片" force-render><PictureList :picture-list="pictureList"/></a-tab-pane>
    
    <a-tab-pane key="user" tab="用户">
      <UserList :user-list="userList"/></a-tab-pane>
    
  </a-tabs>
  </div>
  
</template>

<script setup lang="ts">
import {ref, watchEffect} from 'vue';
import PostList from '@/components/PostList.vue';
import PictureList from '@/components/PictureList.vue';
import UserList from '@/components/UserList.vue';
import MyDivider from '@/components/MyDivider.vue';
import { useLink, useRoute, useRouter } from 'vue-router';
import myAxios from '@/plugins/myAxios';
import { message } from 'ant-design-vue';
//创建路由实例
const router = useRouter();
//获取路由所有信息
const route = useRoute();
const activeKey = route.params.category;
const initSearchParams = {
  type: activeKey,
  text:"",
  pageSize: 10,
  pageNum: 1,
};
const searchText = ref(route.query.text || "");
//把initSearchParams变为响应式对象
const searchParams = ref(initSearchParams);
const postList = ref([]);
const userList = ref([]);
const pictureList = ref([]);
//旧 ：加载数据
const loadDataOld = (params: any) => {
  const pictureQuery = {
    ...params,
    searchText: params.text,
  };
  myAxios.post("/picture/search/page/vo",pictureQuery).then((res: any) => {
  pictureList.value = res.records;
});
  const postQuery = {
    ...params,
    searchText: params.text,
  };
  myAxios.post("/post/list/page/vo", postQuery).then((res: any) => {
  postList.value = res.records;
});
const userQuery = {
  ...params,
  userName: params.text,
}
myAxios.post("/user/list/page/vo", userQuery).then((res: any) => {
  userList.value = res.records;
});
};
//新 ：加载聚合数据
const loadAllData = (params: any) => {
  const query = {
    ...params,
    searchText: params.text,
  };
  myAxios.post("/search/all",query).then((res: any) => {
  userList.value = res.userList;
  pictureList.value = res.pictureList;
  postList.value = res.postList;
});
};
//更新 ：加载单类数据
const loadData = (params: any) => {
  const {type} = params;
  if(!type){
    message.error("类别为空");
    return;
  }
   const query = {
    ...params,
    searchText: params.text,
  };
  myAxios.post("/search/all",query).then((res: any) => {
  if(type === "post"){
  postList.value = res.postList;
  }else if(type === "user"){
  userList.value = res.userList;
  }else if(type === "picture"){
  pictureList.value = res.pictureList;
  }
});
};
//监视路由变化
watchEffect(() =>{
  searchParams.value = {
  ...initSearchParams,
  text: route.query.text,
  type: route.params.category,
  } as any;
  loadData(searchParams.value);
});
//用户每次搜索
loadData(initSearchParams);
const onSearch = (value: string) =>{
  //把搜索框里面的内容压到路由中
  router.push({
    query:{
      ...searchParams.value,
      text: value,
    },
  });
  loadData(searchParams.value);
};
//每次导航栏切换
const onTabChange = (key: string) => {
  router.push({
    path: `/${key}`,
    query: searchParams.value,
  });
};
</script>

适配器模式

  1. 定制统一的数据源接入范围
  2. 适配器模式的作用：通过转换，让两个系统能够对接

后端数据源统一接口

package com.yupi.springbootinit.dataSource;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.poi.ss.formula.functions.T;

/**
 * 数据源接口
 * （新接入的数据源必须实现）
 */
public interface DataSource<T> {

    Page<T> doSearch(String searchText, long pageNum, long pageSize);
}

图片适配器

package com.yupi.springbootinit.dataSource;

import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yupi.springbootinit.common.ErrorCode;
import com.yupi.springbootinit.exception.BusinessException;
import com.yupi.springbootinit.model.entity.Picture;
import com.yupi.springbootinit.service.PictureService;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 帖子服务实现
 *
 *
 *
 */
@Service
@Slf4j
public class PictureDataSource implements DataSource<Picture> {

    @Override
    public Page<Picture> doSearch(String searchText, long pageNum, long pageSize) {
        long current = (pageNum - 1) * pageSize;
        String url = String.format("https://cn.bing.com/images/search?q=%s&first=%s",searchText,current);
        Document doc = null;
        try {
            doc = Jsoup.connect(url).get();
        } catch (IOException e) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "数据抓取失败");
        }
        Elements elements = doc.select(".iuscp.isv"); //数组，每个元素是每一张图片
        List<Picture> pictures = new ArrayList<>();
        for (Element element : elements) {
            //取图片地址murl
            String m = element.select(".iusc").attr("m");
            Map<String, Object> map = JSONUtil.toBean(m, Map.class);
            String murl = (String) map.get("murl");
            //取标题
            String title = element.select(".inflnk").attr("aria-label");
            Picture picture = new Picture();
            picture.setTitle(title);
            picture.setUrl(murl);
            pictures.add(picture);
            if (pictures.size() >= pageSize)
                break;
        }
        Page<Picture> picturePage = new Page<>(pageNum,pageSize);
        picturePage.setRecords(pictures);
        return  picturePage;
    }
}

帖子适配器

package com.yupi.springbootinit.dataSource;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yupi.springbootinit.common.ErrorCode;
import com.yupi.springbootinit.constant.CommonConstant;
import com.yupi.springbootinit.exception.BusinessException;
import com.yupi.springbootinit.exception.ThrowUtils;
import com.yupi.springbootinit.mapper.PostFavourMapper;
import com.yupi.springbootinit.mapper.PostMapper;
import com.yupi.springbootinit.mapper.PostThumbMapper;
import com.yupi.springbootinit.model.dto.post.PostEsDTO;
import com.yupi.springbootinit.model.dto.post.PostQueryRequest;
import com.yupi.springbootinit.model.entity.Post;
import com.yupi.springbootinit.model.entity.PostFavour;
import com.yupi.springbootinit.model.entity.PostThumb;
import com.yupi.springbootinit.model.entity.User;
import com.yupi.springbootinit.model.vo.PostVO;
import com.yupi.springbootinit.model.vo.UserVO;
import com.yupi.springbootinit.service.PostService;
import com.yupi.springbootinit.service.UserService;
import com.yupi.springbootinit.utils.SqlUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.sort.SortBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 帖子服务实现
 */
@Service
@Slf4j
public class PostDataSource extends ServiceImpl<PostMapper, Post> implements DataSource<PostVO> {


    @Resource
    private PostService postService;

    @Override
    public Page<PostVO> doSearch(String searchText, long pageNum, long pageSize) {
        PostQueryRequest postQueryRequest = new PostQueryRequest();
        postQueryRequest.setSearchText(searchText);
        postQueryRequest.setCurrent(pageNum);
        postQueryRequest.setPageSize(pageSize);
        HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
        Page<PostVO> postVOPage = postService.listPostVOByPage(postQueryRequest, request);
        return postVOPage;
    }
}

用户适配器

package com.yupi.springbootinit.dataSource;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yupi.springbootinit.common.ErrorCode;
import com.yupi.springbootinit.constant.CommonConstant;
import com.yupi.springbootinit.exception.BusinessException;
import com.yupi.springbootinit.mapper.UserMapper;
import com.yupi.springbootinit.model.dto.user.UserQueryRequest;
import com.yupi.springbootinit.model.entity.User;
import com.yupi.springbootinit.model.enums.UserRoleEnum;
import com.yupi.springbootinit.model.vo.LoginUserVO;
import com.yupi.springbootinit.model.vo.UserVO;
import com.yupi.springbootinit.service.UserService;
import com.yupi.springbootinit.utils.SqlUtils;
import lombok.extern.slf4j.Slf4j;
import me.chanjar.weixin.common.bean.WxOAuth2UserInfo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import javax.annotation.RegEx;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import static com.yupi.springbootinit.constant.UserConstant.USER_LOGIN_STATE;

/**
 * 用户服务实现
 *
 *
 *
 */
@Service
@Slf4j
public class UserDataSource extends ServiceImpl<UserMapper, User> implements DataSource {

    @Resource
    private UserService userService;

    @Override
    public Page doSearch(String searchText, long pageNum, long pageSize) {
        UserQueryRequest userQueryRequest = new UserQueryRequest();
        userQueryRequest.setUserName(searchText);
        Page<User> userPage = this.page(new Page<>(pageNum, pageSize),
                userService.getQueryWrapper(userQueryRequest));
        Page<UserVO> userVOPage = new Page<>(pageNum, pageSize, userPage.getTotal());
        List<UserVO> userVO = userService.getUserVO(userPage.getRecords());
        userVOPage.setRecords(userVO);
        return userVOPage;
    }
}

修改SearchFacade

@Component
@Slf4j
public class SearchFacade {
    @Resource
    private PictureDataSource pictureDataSource;


    @Resource
    private UserDataSource userDataSource;

    @Resource
    private PostDataSource postDataSource;

    public SearchVO searchAll(@RequestBody SearchRequest searchRequest, HttpServletRequest request) {
        String type = searchRequest.getType();
        ThrowUtils.throwIf(StringUtils.isBlank(type), ErrorCode.PARAMS_ERROR);
        SearchTypeEnum searchTypeEnum = SearchTypeEnum.getEnumByValue(type);
        String searchText = searchRequest.getSearchText();
        long current = searchRequest.getCurrent();
        long pageSize = searchRequest.getPageSize();
        if(searchTypeEnum ==  null){
            CompletableFuture<Page<UserVO>> userTask = CompletableFuture.supplyAsync(() ->{
                UserQueryRequest userQueryRequest = new UserQueryRequest();
                userQueryRequest.setUserName(searchText);
                Page<UserVO> userVOPage = userDataSource.doSearch(searchText,current,pageSize);
                return userVOPage;
            });
            CompletableFuture<Page<PostVO>> postTask = CompletableFuture.supplyAsync(()->{
                PostQueryRequest postQueryRequest = new PostQueryRequest();
                postQueryRequest.setSearchText(searchText);
                Page<PostVO> postVOPage = postDataSource.doSearch(searchText,current,pageSize);
                return postVOPage;
            });
            CompletableFuture<Page<Picture>> pictureTask = CompletableFuture.supplyAsync(()->{
                Page<Picture> picturePage = pictureDataSource.doSearch(searchText, 1, 10);
                return picturePage;
            });
            //聚合
            CompletableFuture.allOf(userTask,postTask,pictureTask).join();
            try {
                Page<UserVO> userVOPage = userTask.get();
                Page<PostVO> postVOPage = postTask.get();
                Page<Picture> picturePage = pictureTask.get();
                SearchVO searchVO = new SearchVO();
                searchVO.setUserList(userVOPage.getRecords());
                searchVO.setPictureList(picturePage.getRecords());
                searchVO.setPostList(postVOPage.getRecords());
                return  searchVO;
            }catch (Exception e){
                log.error("查询异常",e);
                throw new BusinessException(ErrorCode.SYSTEM_ERROR,"查询异常");
            }
        }else{
            Map<String, DataSource> typeDataSourceMap = new HashMap(){{
             put(SearchTypeEnum.POST.getValue(),postDataSource);
             put(SearchTypeEnum.USER.getValue(),userDataSource);
             put(SearchTypeEnum.PICTURE.getValue(),pictureDataSource);
            }};
            SearchVO searchVO = new SearchVO();
            DataSource dataSource = typeDataSourceMap.get(type);
            Page page = dataSource.doSearch(searchText, current, pageSize);
            searchVO.setDataList(page.getRecords());
            return  searchVO;
        }
    }

}

注册器模式

（本质也是单例）
提前用一个map或者其他类型存储好后面需要调用的对象。
作用：代码量大幅度减少，可维护可扩展

注册器

@Component
public class DataSourceRegistry {

    @Resource
    private PictureDataSource pictureDataSource;


    @Resource
    private UserDataSource userDataSource;

    @Resource
    private PostDataSource postDataSource;

    private Map<String, DataSource> typeDataSourceMap;

    /**
     * @PostConstruct标识的方法会在Spring容器完成依赖注入后立即执行。
     * 没有这个初始化方法的话，依赖注入以后还没有执行typeDataSourceMap的赋值操作，就调用了getDataSourceByType方法，肯定是返回空的
     */
    @PostConstruct
    public void init() {
        typeDataSourceMap = new HashMap() {
            {
                put(SearchTypeEnum.POST.getValue(), postDataSource);
                put(SearchTypeEnum.USER.getValue(), userDataSource);
                put(SearchTypeEnum.PICTURE.getValue(), pictureDataSource);
            }
        };
    }

    public DataSource getDataSourceByType(String type) {
        if(typeDataSourceMap == null){
            return null;
        }
        return typeDataSourceMap.get(type);
    }
}

SearFacade类又精简了

@Component
@Slf4j
public class SearchFacade {
    @Resource
    private PictureDataSource pictureDataSource;


    @Resource
    private UserDataSource userDataSource;

    @Resource
    private PostDataSource postDataSource;

    @Resource
    private DataSourceRegistry dataSourceRegistry;

    public SearchVO searchAll(@RequestBody SearchRequest searchRequest, HttpServletRequest request) {
        String type = searchRequest.getType();
        ThrowUtils.throwIf(StringUtils.isBlank(type), ErrorCode.PARAMS_ERROR);
        SearchTypeEnum searchTypeEnum = SearchTypeEnum.getEnumByValue(type);
        String searchText = searchRequest.getSearchText();
        long current = searchRequest.getCurrent();
        long pageSize = searchRequest.getPageSize();
        if(searchTypeEnum ==  null){
            CompletableFuture<Page<UserVO>> userTask = CompletableFuture.supplyAsync(() ->{
                UserQueryRequest userQueryRequest = new UserQueryRequest();
                userQueryRequest.setUserName(searchText);
                Page<UserVO> userVOPage = userDataSource.doSearch(searchText,current,pageSize);
                return userVOPage;
            });
            CompletableFuture<Page<PostVO>> postTask = CompletableFuture.supplyAsync(()->{
                PostQueryRequest postQueryRequest = new PostQueryRequest();
                postQueryRequest.setSearchText(searchText);
                Page<PostVO> postVOPage = postDataSource.doSearch(searchText,current,pageSize);
                return postVOPage;
            });
            CompletableFuture<Page<Picture>> pictureTask = CompletableFuture.supplyAsync(()->{
                Page<Picture> picturePage = pictureDataSource.doSearch(searchText, 1, 10);
                return picturePage;
            });
            //聚合
            CompletableFuture.allOf(userTask,postTask,pictureTask).join();
            try {
                Page<UserVO> userVOPage = userTask.get();
                Page<PostVO> postVOPage = postTask.get();
                Page<Picture> picturePage = pictureTask.get();
                SearchVO searchVO = new SearchVO();
                searchVO.setUserList(userVOPage.getRecords());
                searchVO.setPictureList(picturePage.getRecords());
                searchVO.setPostList(postVOPage.getRecords());
                return  searchVO;
            }catch (Exception e){
                log.error("查询异常",e);
                throw new BusinessException(ErrorCode.SYSTEM_ERROR,"查询异常");
            }
        }else{
            SearchVO searchVO = new SearchVO();
            DataSource dataSource = dataSourceRegistry.getDataSourceByType(type);
            Page page = dataSource.doSearch(searchText, current, pageSize);
            searchVO.setDataList(page.getRecords());
            return  searchVO;
        }
    }

}
诨号无敌鸭
关注
  • 36
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
商业编程-源码-聚合搜索1.10版源码.zip
06-23
商业编程-源码-聚合搜索1.10版源码.zip
基于Java的ADmobile ADSuyi-Flutter插件广告聚合SDK设计源码
05-22
ADmobile ADSuyi-Flutter广告聚合SDK：基于Java开发的插件，包含126个文件，支持Dart、Swift、C和MATLAB语言。该SDK旨在帮助移动开发者快速集成和管理多个广告平台，包括优量汇、穿山甲、快手联盟等主流移动广告平台...
华为HCIA进阶笔记：Eth-Trunk 链路聚合
06-19
华为HCIA实验 - Eth-Trunk 链路聚合 & eNSP
【推荐】张逸-DDD聚合工作坊
06-05
pdf文件，29页，张逸-DDD聚合工作坊，精品一级
基于载波聚合技术的FDD-LTE网络设计方案
01-27
对载波聚合技术特点、类型和应用场景进行分析，通过一个Band 3 （1.8 GHz）+Band 3 （1.8 GHz）带内连续载波的组合设计方案案例，网络环境选取可用的测试点和测试卡对10 M频段与FDD的20 M频段进行载波聚合，采用工具...
设计模式-享元模式
楠姐的博客
05-29 689
享元模式（Flyweight Pattern）是一种用于效率和内存优化的结构型设计模式。这种模式通过共享尽可能多的相似对象来减少内存使用，特别适合于处理大量对象时，每个对象都消耗大量内存的场景。总的来说，享元模式在处理大量相似对象时提供了一种有效的内存优化策略。然而，它的使用应当谨慎，需要正确评估和设计内部状态和外部状态，以确保不会对应用程序的逻辑造成负面影响。在 JavaScript 等动态语言中，享元模式可以帮助管理内存消耗，尤其是在客户端浏览器环境中，这对提升用户体验和应用性能都是非常有益的。
设计模式21——命令模式
weixin_43687024的博客
05-29 1064
1、将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。2、可以在 根据请求执行命令的类 里、设计一个命令队列，把 声明接收者执行哪些命令的类 保存起来；3、允许接受请求的一方拒绝请求。
设计模式复习
m0_68728226的博客
05-29 327
UML图例 5种创建型口诀:抽象工厂 按照 工厂方法，生成 单例 原型 7种结构型口诀:外观 装饰 按照 适配 的方式 桥接 组合，给 亨元 代理 记住前面的12种，剩下的都是行为型创建型模式结构型模式行为型模式（1） 行为型模式（2）
设计模式深度解析：分布式与中心化，IT界两大巨头“华山论剑”
制定明确可量化的目标，坚持默默的做事。
05-26 2508
分布式模式与中心化模式各有其独特的优势和局限性。分布式模式因其高容错性和适应大规模复杂系统的能力，在处理大数据和高并发场景中具有显著优势，然而，其节点间数据传输的安全性要求高，且开发调试难度较大，这是其面临的挑战。相比之下，中心化模式在安全控制和开发维护方面更具优势，适用于对安全性和稳定性要求较高的场景。在选择时，需综合考虑业务需求和技术要求，权衡利弊。未来，随着云计算、边缘计算等技术的发展，两种模式将迎来新的机遇与挑战，需灵活调整策略，确保系统高效稳定运行。
【React篇】简述React-Router 的实现原理及工作方式
遇见小美好
05-30 290
简述React-Router 的实现原理及工作方式
Java设计模式 _行为型模式_访问者模式
weisian的博客
05-30 236
访问者模式，主要包含访问者和被访问者两种角色的实体，两者之间相互关联，被访问者依附于访问者，访问者可以访问被访问者的方法。学海无涯苦作舟！！！
设计模式-外观模式
楠姐的博客
05-29 490
外观模式（Facade Pattern）是软件工程中用于提供一个统一的接口来访问复杂子系统的结构型设计模式。这个模式的主要目的是隐藏系统的复杂性，并为客户端提供一个可以访问系统的接口。它通常涉及一个单一的类，这个类提供了客户端所需的方法，而这些方法则将客户端的请求委托给系统中的一个或多个模块处理。外观模式是一个非常实用的设计模式，适用于那些需要定义简单接口来访问复杂系统的情况，尤其是在整合和维护大型软件系统时非常有效。在实际应用中，它帮助我们隐藏了系统的复杂性，提供了一个清晰和简单的接口给系统的使用者。
设计模式18—— 迭代器模式
weixin_43687024的博客
05-28 543
1、提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。2、当你需要访问一个聚集（合）对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。3、当你需要对聚集（合）有多种方式遍历时，可以考虑用迭代器模式。4、为遍历不同的聚集（合）结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。5、分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据。
【设计模式】JAVA Design Patterns——Curiously Recurring Template Pattern（奇异递归模板模式）
CSBIGDOG的博客
05-27 437
奇异递归模板模式（curiously recurring template pattern，CRTP）是C++模板编程时的一种惯用法：其中类X派生自使用X本身作为模板参数的类模板实例化。对于正在策划赛事的综合格斗推广活动来说，确保在相同重量级的运动员之间组织比赛至关重要。这样可以防止体型明显不同的拳手之间的不匹配，例如重量级拳手与雏量级拳手的对决。效果： 允许拳手与相同重量级的对手交手，如果对手是不同重量级，则会出现错误。使类型中的某些方法接受特定于其子类型的参数。定义MmaFighter 的一些子类型。
简述MVC模式
zxf347085420的博客
05-28 312
一般来说，MVC模式就是通过Controller控制层监听用户的请求事件，通过访问Model数据层，对数据进行相应的增删改查操作，然后找到合适的View视图用相应的数据进行渲染生成最终的显示视图（可以是图形界面，html web页面，json，protobuff等等），然后再把视图返回给用户。C：指的是Controller，控制层，表示监听用户事件交互，分发处理事件模块。M：指的是Model，数据模型层，表示系统底层的数据操作模块。V：指的是View，视图显示层，表示系统对于数据的展示模块。
C++设计模式-策略模式
最新发布
qq_42692132的博客
05-31 207
C++设计模式-策略模式
设计模式20——职责链模式
weixin_43687024的博客
05-29 1405
1、使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。2、职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接收者的引用。3、可以随时增加或修改处理一个请求的结构，增强了给对象指派职责的灵活性。
行为设计模式之策略模式
yajunjiao的专栏
05-27 462
策略模式(strategy pattern)的原始定义是：定义一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法可以独立于使用它的客户端而变化。很常用的，我们出门，可以有很多种出行方式，目的都是到达某地，方法多种多样。
妙解设计模式之策略模式
m0_50281408的博客
05-27 573
策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，把它们一个个封装起来，并且使它们可以相互替换。这种模式使得算法可以独立于使用它的客户端而变化。
链路聚合接口怎么作为dhcp-sooping的信任口？
03-27
要将链路聚合接口作为dhcp-snooping的信任口，需要执行以下步骤： 1. 禁用链路聚合接口上的DHCP服务，并将其配置为被动接口。可以使用以下命令禁用DHCP服务： switch(config)# interface port-channel 1 switch...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值