【设计模式】《Java 设计模式魔法：解锁高效编程的秘密武器》

在这里插入图片描述

标题：《Java 设计模式奇幻之旅：解锁高效编程的魔法钥匙》

摘要： 本文将深入探讨 Java 中的十种设计模式，包括单例模式、工厂方法模式、抽象工厂模式…迭代器模式、组合模式、模板方法模式等。通过详细的解释、生动有趣的例子以及可运行的 Java 代码，帮助读者理解这些设计模式的核心思想和应用场景。读者将从中获得提升代码质量、增强可维护性和可扩展性的宝贵知识，开启高效编程的奇幻之旅。

关键词：Java 设计模式、单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、适配器模式、装饰器模式、外观模式、代理模式、观察者模式、迭代器模式、组合模式、模板方法模式、命令模式、策略模式、状态模式、备忘录模式、中介者模式、责任链模式、访问者模式

一、单例模式（Singleton）

  1. 核心思想：确保一个类只有一个实例，并提供一个全局访问点。
    • 例子：想象一个公司只有一个 CEO。无论在公司的哪个部门，当需要找 CEO 做决策时，都能通过一个特定的途径找到同一个 CEO，而不是有多个不同的“CEO”。
    • Java 代码：
class Singleton {private static Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}
}

二、工厂方法模式（Factory Method）

  1. 核心思想：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。
    • 例子：比如有一个汽车工厂，工厂有一个生产汽车的接口。不同的分厂可以根据需求生产不同类型的汽车，如轿车分厂生产轿车，SUV 分厂生产 SUV。
    • Java 代码：
interface Car {void drive();
}class Sedan implements Car {@Overridepublic void drive() {System.out.println("Driving Sedan.");}
}class SUV implements Car {@Overridepublic void drive() {System.out.println("Driving SUV.");}
}abstract class CarFactory {public abstract Car createCar();
}class SedanFactory extends CarFactory {@Overridepublic Car createCar() {return new Sedan();}
}class SUVFactory extends CarFactory {@Overridepublic Car createCar() {return new SUV();}
}

三、抽象工厂模式（Abstract Factory）

  1. 核心思想：创建一个系列相关的或依赖对象的接口，而不需要明确指定它们具体的类。
    • 例子：假设你在装修房子，有不同的装修风格套餐，比如现代风格套餐包含现代风格的沙发、餐桌等家具；欧式风格套餐包含欧式风格的家具。抽象工厂就像是提供不同风格套餐的装修公司。
    • Java 代码：
interface Furniture {void display();
}class ModernSofa implements Furniture {@Overridepublic void display() {System.out.println("Modern Sofa.");}
}class ModernTable implements Furniture {@Overridepublic void display() {System.out.println("Modern Table.");}
}class EuropeanSofa implements Furniture {@Overridepublic void display() {System.out.println("European Sofa.");}
}class EuropeanTable implements Furniture {@Overridepublic void display() {System.out.println("European Table.");}
}interface FurnitureFactory {Furniture createSofa();Furniture createTable();
}class ModernFurnitureFactory implements FurnitureFactory {@Overridepublic Furniture createSofa() {return new ModernSofa();}@Overridepublic Furniture createTable() {return new ModernTable();}
}class EuropeanFurnitureFactory implements FurnitureFactory {@Overridepublic Furniture createSofa() {return new EuropeanSofa();}@Overridepublic Furniture createTable() {return new EuropeanTable();}
}

四、建造者模式（Builder）

  1. 核心思想：允许通过指定复杂对象的类型和内容逐步构建对象，以避免使用多个构造函数或设置器。
    • 例子：比如建造一个房子，有不同的部分如地基、墙壁、屋顶等。建造者模式可以让你逐步构建房子，先打地基，然后砌墙，最后安装屋顶，而不是一次性用一个复杂的构造函数来创建房子。
    • Java 代码：
class House {private String foundation;private String walls;private String roof;public void setFoundation(String foundation) {this.foundation = foundation;}public void setWalls(String walls) {this.walls = walls;}public void setRoof(String roof) {this.roof = roof;}@Overridepublic String toString() {return "House{" +"foundation='" + foundation + '\'' +", walls='" + walls + '\'' +", roof='" + roof + '\'' +'}';}
}interface HouseBuilder {void buildFoundation();void buildWalls();void buildRoof();House getHouse();
}class ConcreteHouseBuilder implements HouseBuilder {private House house = new House();@Overridepublic void buildFoundation() {house.setFoundation("Strong foundation");}@Overridepublic void buildWalls() {house.setWalls("Brick walls");}@Overridepublic void buildRoof() {house.setRoof("Tiled roof");}@Overridepublic House getHouse() {return house;}
}

五、原型模式（Prototype）

  1. 核心思想：通过复制现有的实例创建新的实例，而不是通过新建。
    • 例子：想象你有一个复杂的图形设计软件，你已经花了很多时间设计了一个漂亮的图形。现在你想在这个基础上做一些小的修改来创建一个新的图形，而不是从头开始设计。原型模式就可以让你复制这个现有的图形，然后进行修改。
    • Java 代码：
class Graphic {private String color;private int size;public Graphic(String color, int size) {this.color = color;this.size = size;}public Graphic clone() {return new Graphic(this.color, this.size);}@Overridepublic String toString() {return "Graphic{" +"color='" + color + '\'' +", size=" + size +'}';}
}

六、适配器模式（Adapter）

  1. 核心思想：允许不兼容的接口一起工作，通过一个转换接口的类来适配它们。
    • 例子：比如你有一个旧的手机充电器，它的接口和你的新手机不兼容。这时你可以使用一个适配器，将旧充电器的接口转换为新手机可以使用的接口。
    • Java 代码：
interface Target {void charge();
}class NewPhone {public void chargeWithNewInterface() {System.out.println("Charging with new interface.");}
}class Adapter implements Target {private NewPhone newPhone;public Adapter(NewPhone newPhone) {this.newPhone = newPhone;}@Overridepublic void charge() {newPhone.chargeWithNewInterface();}
}

七、装饰器模式（Decorator）

  1. 核心思想：动态地给一个对象添加额外的职责，而不改变其结构。
    • 例子：想象你有一杯咖啡，你可以通过添加糖、牛奶等装饰来改变咖啡的味道，而不需要改变咖啡本身的结构。
    • Java 代码：
interface Coffee {double getCost();String getDescription();
}class SimpleCoffee implements Coffee {@Overridepublic double getCost() {return 2.0;}@Overridepublic String getDescription() {return "Simple coffee";}
}class CoffeeDecorator implements Coffee {protected Coffee coffee;public CoffeeDecorator(Coffee coffee) {this.coffee = coffee;}@Overridepublic double getCost() {return coffee.getCost();}@Overridepublic String getDescription() {return coffee.getDescription();}
}class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) {super(coffee);}@Overridepublic double getCost() {return super.getCost() + 0.5;}@Overridepublic String getDescription() {return super.getDescription() + ", with milk";}
}class SugarDecorator extends CoffeeDecorator {public SugarDecorator(Coffee coffee) {super(coffee);}@Overridepublic double getCost() {return super.getCost() + 0.2;}@Overridepublic String getDescription() {return super.getDescription() + ", with sugar";}
}

八、外观模式（Facade）

  1. 核心思想：提供一个统一的高层接口，用于访问子系统中的一群接口。
    • 例子：想象你有一个复杂的音响系统，有很多按钮和设置。外观模式可以提供一个简单的遥控器，让你可以通过几个简单的按钮来控制整个音响系统，而不需要直接操作每个组件。
    • Java 代码：
class Amplifier {public void on() {System.out.println("Amplifier on.");}public void off() {System.out.println("Amplifier off.");}
}class Tuner {public void tune() {System.out.println("Tuner tuned.");}
}class DvdPlayer {public void play() {System.out.println("DVD player playing.");}public void stop() {System.out.println("DVD player stopped.");}
}class Projector {public void on() {System.out.println("Projector on.");}public void off() {System.out.println("Projector off.");}
}class Screen {public void up() {System.out.println("Screen up.");}public void down() {System.out.println("Screen down.");}
}class HomeTheaterFacade {private Amplifier amplifier;private Tuner tuner;private DvdPlayer dvdPlayer;private Projector projector;private Screen screen;public HomeTheaterFacade() {amplifier = new Amplifier();tuner = new Tuner();dvdPlayer = new DvdPlayer();projector = new Projector();screen = new Screen();}public void watchMovie() {amplifier.on();tuner.tune();dvdPlayer.play();projector.on();screen.down();}public void endMovie() {amplifier.off();tuner.off();dvdPlayer.stop();projector.off();screen.up();}
}

九、代理模式（Proxy）

  1. 核心思想：为其他对象提供一个代替或占位符，以控制对它的访问。
    • 例子：想象你是一个明星的经纪人。当有人想要联系明星时，他们需要通过你来安排。你就是明星的代理，控制着对明星的访问。
    • Java 代码：
interface Star {void act();
}class RealStar implements Star {@Overridepublic void act() {System.out.println("Star is acting.");}
}class StarProxy implements Star {private RealStar realStar;public StarProxy() {realStar = new RealStar();}@Overridepublic void act() {System.out.println("Checking if star is available...");realStar.act();}
}

十、观察者模式（Observer）

  1. 核心思想：对象间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。
    • 例子：比如你在一个新闻网站上订阅了一些新闻频道。当有新的新闻发布时，新闻网站会通知所有订阅了该频道的用户。用户就是观察者，新闻网站就是被观察的对象。
    • Java 代码：
interface Observer {void update();
}class NewsWebsite implements Observer {private String news;@Overridepublic void update() {System.out.println("News received: " + news);}public void setNews(String news) {this.news = news;}
}class NewsPublisher {private List<Observer> observers = new ArrayList<>();public void addObserver(Observer observer) {observers.add(observer);}public void removeObserver(Observer observer) {observers.remove(observer);}public void publishNews(String news) {System.out.println("New news published: " + news);for (Observer observer : observers) {observer.update();}}
}

十一、迭代器模式（Iterator）

  1. 核心思想：顺序访问一个聚合对象中的各个元素，不暴露其内部的表示。
    • 例子：想象你有一个装满玩具的箱子，你想一个一个地拿出玩具来玩，但你不需要知道箱子是如何存储玩具的。迭代器就像是你的小手，能够逐个取出玩具，而不关心箱子的内部结构。
    • Java 代码：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;class Toy {private String name;public Toy(String name) {this.name = name;}public String getName() {return name;}
}class ToyBox implements Iterable<Toy> {private List<Toy> toys = new ArrayList<>();public void addToy(Toy toy) {toys.add(toy);}@Overridepublic Iterator<Toy> iterator() {return toys.iterator();}
}

十二、组合模式（Composite）

  1. 核心思想：将对象组合成树形结构以表示“部分-整体”的层次结构。
    • 例子：想象一个公司的组织结构，有部门和员工。部门可以包含子部门和员工，就像一棵树。组合模式可以让你统一处理部门和员工，无论是计算工资还是执行其他操作。
    • Java 代码：
interface OrganizationComponent {void displayInfo();
}class Employee implements OrganizationComponent {private String name;public Employee(String name) {this.name = name;}@Overridepublic void displayInfo() {System.out.println("Employee: " + name);}
}class Department implements OrganizationComponent {private String name;private List<OrganizationComponent> components = new ArrayList<>();public Department(String name) {this.name = name;}public void addComponent(OrganizationComponent component) {components.add(component);}@Overridepublic void displayInfo() {System.out.println("Department: " + name);for (OrganizationComponent component : components) {component.displayInfo();}}
}

十三、模板方法模式（Template Method）

  1. 核心思想：在一个方法中定义算法的骨架，将一些步骤的执行延迟到子类中。
    • 例子：比如做蛋糕，有一个基本的流程是准备材料、搅拌、烘烤、装饰。不同类型的蛋糕在某些步骤上可能会有所不同，比如巧克力蛋糕和水果蛋糕的装饰方式不同。模板方法模式就可以定义这个做蛋糕的基本流程，而具体的装饰步骤由子类实现。
    • Java 代码：
abstract class CakeMaking {public final void makeCake() {prepareIngredients();mixIngredients();bake();decorate();}protected abstract void decorate();protected void prepareIngredients() {System.out.println("Preparing common ingredients.");}protected void mixIngredients() {System.out.println("Mixing ingredients.");}protected void bake() {System.out.println("Baking the cake.");}
}class ChocolateCake extends CakeMaking {@Overrideprotected void decorate() {System.out.println("Decorating with chocolate.");}
}class FruitCake extends CakeMaking {@Overrideprotected void decorate() {System.out.println("Decorating with fruits.");}
}

十四、命令模式（Command）

  1. 核心思想：将请求或操作封装为一个对象，从而使用户可用不同的请求、队列或日志请求来参数化其他对象。
    • 例子：想象你有一个遥控器，上面有不同的按钮，每个按钮代表一个命令，比如打开电视、切换频道等。命令模式可以将这些操作封装成一个个命令对象，当你按下按钮时，就执行相应的命令。
    • Java 代码：
interface Command {void execute();
}class TurnOnTVCommand implements Command {private TV tv;public TurnOnTVCommand(TV tv) {this.tv = tv;}@Overridepublic void execute() {tv.turnOn();}
}class TV {public void turnOn() {System.out.println("TV is turned on.");}public void turnOff() {System.out.println("TV is turned off.");}
}

十五、策略模式（Strategy）

  1. 核心思想：定义一系列算法，把它们一个个封装起来，并使它们可互换。
    • 例子：想象你要去旅行，可以选择不同的交通方式，比如坐飞机、坐火车、开车。策略模式可以让你根据不同的情况选择不同的交通方式，而不需要修改旅行的其他部分。
    • Java 代码：
interface TravelStrategy {void travel();
}class FlyStrategy implements TravelStrategy {@Overridepublic void travel() {System.out.println("Traveling by air.");}
}class TrainStrategy implements TravelStrategy {@Overridepublic void travel() {System.out.println("Traveling by train.");}
}class DriveStrategy implements TravelStrategy {@Overridepublic void travel() {System.out.println("Traveling by car.");}
}class Traveler {private TravelStrategy strategy;public void setStrategy(TravelStrategy strategy) {this.strategy = strategy;}public void travel() {strategy.travel();}
}

十六、状态模式（State）

  1. 核心思想：允许一个对象在其内部状态改变时改变它的行为，看起来好像改变了其类。
    • 例子：想象一个手机，有不同的状态，比如开机状态、关机状态、飞行模式状态等。当手机处于不同状态时，它的行为也不同，比如在开机状态可以打电话、发短信，在关机状态则不能。状态模式可以让手机根据不同的状态自动切换行为。
    • Java 代码：
interface PhoneState {void handle();
}class OnState implements PhoneState {@Overridepublic void handle() {System.out.println("Phone is on. You can make calls and send messages.");}
}class OffState implements PhoneState {@Overridepublic void handle() {System.out.println("Phone is off.");}
}class FlightModeState implements PhoneState {@Overridepublic void handle() {System.out.println("Phone is in flight mode. You can't make calls.");}
}class Phone {private PhoneState state;public Phone() {state = new OffState();}public void setState(PhoneState state) {this.state = state;}public void handleState() {state.handle();}
}

十七、备忘录模式（Memento）

  1. 核心思想：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
    • 例子：想象你在玩一个游戏，你可以随时保存游戏进度。备忘录模式就可以让你把游戏当前的状态保存下来，比如角色的位置、生命值等，以便以后可以恢复到这个状态。
    • Java 代码：
class GameState {private int playerHealth;private int playerPosition;public GameState(int health, int position) {playerHealth = health;playerPosition = position;}public int getPlayerHealth() {return playerHealth;}public int getPlayerPosition() {return playerPosition;}
}class Game {private int playerHealth = 100;private int playerPosition = 0;public GameState saveState() {return new GameState(playerHealth, playerPosition);}public void restoreState(GameState state) {playerHealth = state.getPlayerHealth();playerPosition = state.getPlayerPosition();}public void takeDamage(int damage) {playerHealth -= damage;}public void move(int steps) {playerPosition += steps;}
}

十八、中介者模式（Mediator）

  1. 核心思想：用一个中介对象来封装一系列的对象交互，使各对象不需要显示地相互引用。
    • 例子：想象一个办公室里有很多员工，他们需要相互沟通和协作。如果没有中介者，每个员工都需要知道其他所有员工的联系方式，这会很混乱。中介者模式可以引入一个经理作为中介者，员工只需要和经理沟通，经理负责协调员工之间的工作。
    • Java 代码：
interface Colleague {void send(String message);void receive(String message);
}class Employee implements Colleague {private String name;private Mediator mediator;public Employee(String name, Mediator mediator) {this.name = name;this.mediator = mediator;}@Overridepublic void send(String message) {mediator.sendMessage(message, this);}@Overridepublic void receive(String message) {System.out.println(name + " received: " + message);}
}class Mediator {private List<Colleague> colleagues = new ArrayList<>();public void addColleague(Colleague colleague) {colleagues.add(colleague);}public void sendMessage(String message, Colleague sender) {for (Colleague colleague : colleagues) {if (colleague!= sender) {colleague.receive(message);}}}
}

十九、责任链模式（Chain of Responsibility）

  1. 核心思想：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
    • 例子：想象你在一个公司里提交一份报销申请。申请会经过不同的审批人，比如部门经理、财务主管等。如果一个审批人不能批准，申请会传递给下一个审批人。责任链模式可以实现这样的审批流程。
    • Java 代码：
interface Approver {void setNextApprover(Approver approver);void approveRequest(int amount);
}class Manager implements Approver {private Approver nextApprover;@Overridepublic void setNextApprover(Approver approver) {nextApprover = approver;}@Overridepublic void approveRequest(int amount) {if (amount <= 1000) {System.out.println("Manager approved request for $" + amount);} else if (nextApprover!= null) {nextApprover.approveRequest(amount);} else {System.out.println("Request cannot be approved.");}}
}class FinanceDirector implements Approver {private Approver nextApprover;@Overridepublic void setNextApprover(Approver approver) {nextApprover = approver;}@Overridepublic void approveRequest(int amount) {if (amount <= 5000) {System.out.println("Finance Director approved request for $" + amount);} else if (nextApprover!= null) {nextApprover.approveRequest(amount);} else {System.out.println("Request cannot be approved.");}}
}

二十、访问者模式（Visitor）

  1. 核心思想：为一个对象结构（如组合结构）增加新能力，通过访问者对象来实现，而不是修改现有类。
    • 例子：想象你有一个动物园，里面有不同种类的动物。你想统计不同种类动物的数量，或者给不同种类的动物喂食。访问者模式可以让你定义一个访问者对象，它可以访问动物园中的每个动物，并执行特定的操作，而不需要修改动物类。
    • Java 代码：
interface Animal {void accept(Visitor visitor);
}class Lion implements Animal {@Overridepublic void accept(Visitor visitor) {visitor.visitLion(this);}
}class Tiger implements Animal {@Overridepublic void accept(Visitor visitor) {visitor.visitTiger(this);}
}interface Visitor {void visitLion(Lion lion);void visitTiger(Tiger tiger);
}class AnimalCounter implements Visitor {private int lionCount;private int tigerCount;@Overridepublic void visitLion(Lion lion) {lionCount++;}@Overridepublic void visitTiger(Tiger tiger) {tigerCount++;}public void displayCounts() {System.out.println("Number of lions: " + lionCount);System.out.println("Number of tigers: " + tigerCount);}
}

嘿，小伙伴们！这些设计模式是不是超级酷炫呢？快来评论区分享你在编程中使用设计模式的奇妙经历吧！让我们一起在 Java 设计模式的海洋中畅游，创造出更加精彩的代码！😎

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

如何防止U盘盗取电脑数据？

如何防止U盘盗取电脑数据？

数据安全无论是对企业还是个人都至关重要。这些用户群体随时面临着数据被窃取的风险&#xff0c;而 U 盘则成为了潜在的安全隐患。如果你想要禁止电脑上使用 这类USB 存储设备&#xff0c;看完这篇文章&#xff0c;防止 U 盘盗取数据并非难事。 禁止使用usb存储设备 打开电脑上…
阅读更多...
虚拟机 Ubuntu 扩容

虚拟机 Ubuntu 扩容

文章目录 一、Vmware 重新分配 Ubuntu 空间二、Ubuntu 扩容分区 一、Vmware 重新分配 Ubuntu 空间 先打开 Vmware &#xff0c;选择要重新分配空间的虚拟机 点击 编辑虚拟机设置 &#xff0c;再点击 硬盘 &#xff0c;再点击 扩展 选择预计扩展的空间&#xff0c;然后点击 扩展…
阅读更多...
用 AI 革新医学：从早期检测到精准护理

用 AI 革新医学：从早期检测到精准护理

AI 通过实现早期疾病检测、改进诊断和个性化护理来改变医学。 c AI 与放射科医生合作以提高诊断准确性 一段时间以来，AI 一直是医疗诊断的重要辅助工具。一项日本研究表明，ChatGPT 比该领域的专家进行了更准确的评估。 在执行了 150 次诊断后，神经放射学家记录了 AI 的 80…
阅读更多...
vite5 打包项目兼容ie和低版本chrome

vite5 打包项目兼容ie和低版本chrome

背景&#xff1a; vite打包后的项目 在低版本chrome无法使用 直接打包项目在69版本的chrome上无法加载 报错 解决方法&#xff1a; 使用vite官方推荐的插件 vitejs/plugin-legacy 1、下载 npm i vitejs/plugin-legacy -D 2、vite.config.js import legacy from "vit…
阅读更多...
最逼真的AI换脸软件，Pluse下载介绍（可直播）

最逼真的AI换脸软件，Pluse下载介绍（可直播）

Pluse是基于人工智能的实时AI换脸工具&#xff0c;可以在无需任何前期数据训练的情况下&#xff0c;通过一张照片快速替换视频中的人脸&#xff0c;它支持高分辨率细节重建、色彩矫正&#xff0c;并能实时替换多目标人脸&#xff0c;非常适合娱乐社交、影视制作和虚拟现实等多种…
阅读更多...
在米尔电子MPSOC实现12G SDI视频采集H.265压缩SGMII万兆以太网推流

在米尔电子MPSOC实现12G SDI视频采集H.265压缩SGMII万兆以太网推流

1. 引言 随着网络视频平台的发展&#xff0c;用户对于4K高清画质的需求日益增长。然而&#xff0c;许多用户发现&#xff0c;即使购买了视频平台的会员&#xff0c;观看4K内容时画质却不如预期&#xff0c;有时甚至还会出现模糊、卡顿的情况。这种现象背后涉及到视频编码、网络…
阅读更多...
数据结构与算法实验练习（三）（排序及线性表的应用）

数据结构与算法实验练习（三）（排序及线性表的应用）

数据结构与算法分析课下实验练习&#xff0c;现记录一下解答过程&#xff0c;欢迎大家批评指正。 声明&#xff1a;本题目来源于西安交通大学电信学院原盛老师&#xff0c;任何单位或个人在使用、转载或引用本题目时&#xff0c;请务必标明出处为“西安交通大学电信学院原盛老…
阅读更多...
日志代码编写

日志代码编写

&#x1f30e;日志代码编写 文章目录&#xff1a; 日志代码编写 了解日志 日志编写       日志等级       获取时间信息       获取文件名行号及处理可变参数列表       以宏的形式传参       日志加锁       日志消息输出方式 完整代码 …
阅读更多...
HCIA笔记整合

HCIA笔记整合

第一部分&#xff1a; OSI七层模型 应用层&#xff1a;人机交互 抽象语言--------编码 表示层&#xff1a;编码------二进制 会话层&#xff1a;提供会话号 传输层&#xff1a;TCP/UDP 分段&#xff08;收到MTU值的限制&#xff09; MTU&#xff1a;最大传输单元&#xff…
阅读更多...
Kafka集群数据迁移方案

Kafka集群数据迁移方案

概述 MirrorMaker2&#xff08;后文简称 MM2&#xff09;在 2019 年 12 月随 Kafka 2.4.0 一起推出。顾名思义&#xff0c;是为了解决 Kafka 集群之间数据复制和数据同步的问题而诞生的 Kafka 官方的数据复制工具。在实际生产中&#xff0c;经常被用来实现 Kafka 数据的备份&a…
阅读更多...
Prometheus监控平台部署与应用

Prometheus监控平台部署与应用

Prometheus特点 多维数据模型 PromSQL&#xff1a;一种灵活的查询语言&#xff0c;可以利用多维数据完成复杂的查询 不依赖分布式存储&#xff0c;单个服务器节点可直接工作 基于HTTP的pull方式采集时间序列数据 推送时间序列数据通过PushGateway组件支持 通过服务发现或静态配…
阅读更多...
vue3 栅栏式拖拽布局组件

vue3 栅栏式拖拽布局组件

先看效果&#xff1a; 使用方法&#xff1a; 1、npm install fencelayout 2、引入使用 <template><Fencelayout><!-- 需要写的模块直接嵌套在这个下面就可以 --><div class"aaaa"><a-button>模块1</a-button></div><…
阅读更多...
探索设计模式：命令模式

探索设计模式：命令模式

探索设计模式&#xff1a;命令模式 &#x1f9d0;1. 概念&#x1f3af;2. 作用&#x1f4e6;3. 实现3.1 定义命令接口3.2 实现具体命令3.3 实现接收者3.4 实现调用者3.5 使用 &#x1f4bb;4. 应用场景 命令模式&#xff08;Command Pattern&#xff09;就是一种行为型设计模式…
阅读更多...
茅台最新任务脚本

茅台最新任务脚本

茅台最新任务脚本 –小白教程— 这个脚本的作用是实现i茅台应用的自动预约功能&#xff0c;主要功能包括生成请求头、预约商品、计算距离和库存情况、发送微信推送消息等。 代码如下#!/usr/bin/python3cron: 0 0 9/21 * * * new Env(i茅台) import logging import sysimpor…
阅读更多...
​CSS之三

​CSS之三

CSS三大特性 CSS 有三个非常重要的三个特性:层圣性、继承性、优先级 层叠性 相同选择器给设置相同的样式&#xff0c;此时一个样式就会覆盖(层曼)另一个冲突的样式。层曼性主要解决样式冲突的问题 层叠性原则: - 样式冲突&#xff0c;遵循的原则是就近原则&#xff0c;哪个…
阅读更多...
C++设计模式创建型模式———简单工厂模式、工厂方法模式、抽象工厂模式

C++设计模式创建型模式———简单工厂模式、工厂方法模式、抽象工厂模式

文章目录 一、引言二、简单工厂模式三、工厂方法模式三、抽象工厂模式四、总结 一、引言 创建一个类对象的传统方式是使用关键字new &#xff0c; 因为用 new 创建的类对象是一个堆对象&#xff0c;可以实现多态。工厂模式通过把创建对象的代码包装起来&#xff0c;实现创建对…
阅读更多...
python爬虫抓取豆瓣数据教程

python爬虫抓取豆瓣数据教程

环境准备 在开始之前&#xff0c;你需要确保你的Python环境已经安装了以下库&#xff1a; requests&#xff1a;用于发送HTTP请求。BeautifulSoup&#xff1a;用于解析HTML文档。 如果你还没有安装这些库&#xff0c;可以通过以下命令安装&#xff1a; pip install requests…
阅读更多...
代码-画图函数示例

代码-画图函数示例

热力图 import matplotlib.pyplot as plt import seaborn as sns import numpy as npdef create_heatmap(people, categories, dataNone, title热力图, xlabel类别, ylabel人员,value_range(0.6, 0.95), figsize(10, 6),cmapYlOrRd, decimal_places3):"""创建热…
阅读更多...
2024最新Twitter养号全面指南，品牌起号必看！

2024最新Twitter养号全面指南，品牌起号必看！

X (Twitter)作为活跃用户数以亿计的社交媒体平台&#xff0c;用户数依然在不断增长&#xff0c;其中巨大的流量吸引着个人用户与品牌和卖家。 Twitter养号是有必要的&#xff0c;有大量案例表明养好号&#xff0c;可以大幅度降低账号被冻结的几率&#xff0c;并提升账号的稳定…
阅读更多...
百度如何打造AI原生研发新范式？

百度如何打造AI原生研发新范式？

&#x1f449;点击即可下载《百度AI原生研发新范式实践》资料 2024年10月23-25日&#xff0c;2024 NJSD技术盛典暨第十届NJSD软件开发者大会、第八届IAS互联网架构大会在南京召开。本届大会邀请了工业界和学术界的专家&#xff0c;优秀的工程师和产品经理&#xff0c;以及其它行…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023