详解23种设计模式——第二部分:结构型模式

目录

3 结构型模式

3.1 代理模式

3.2 适配器模式

3.2.1 默认适配器模式

3.2.2 对象适配器模式

3.2.3 类适配器模式

3.2.4 适配器模式总结

3.3 桥梁模式

3.4 装饰模式

3.4 门面模式

3.5 组合模式

3.6 享元模式

3.7 结构型模式总结


 接上一篇:详解23种设计模式——第一部分:概述+创建型模式-CSDN博客

3 结构型模式

上一篇文章的创建型模式介绍了创建对象的一些设计模式,这章介绍的结构型模式旨在通过改变代码结构来达到解耦的目的,使得我们的代码容易维护和扩展

3.1 代理模式

第一个要介绍的代理模式是最常使用的模式之一,用一个代理来隐藏具体实现类的实现细节,通常还用于在真实的实现前后添加一部分逻辑。

既然说是代理,那就要对客户端隐藏真实实现,由代理来负责客户端的所有请求。

当然,代理只是个代理,它不会完成实际的业务逻辑,而是一层皮而已,但是对于客户端来说,它必须表现得就是客户端需要的真实实现。

public interface FoodService {Food makeChicken();Food makeNoodle();
}
public class FoodServiceImpl implements FoodService {public Food makeChicken() {Food f = new Chicken()f.setChicken("1kg");f.setSpicy("1g");f.setSalt("3g");return f;}public Food makeNoodle() {Food f = new Noodle();f.setNoodle("500g");f.setSalt("5g");return f;}
}// 代理要表现得“就像是”真实实现类,所以需要实现 FoodService
public class FoodServiceProxy implements FoodService {// 内部一定要有一个真实的实现类,当然也可以通过构造方法注入private FoodService foodService = new FoodServiceImpl();public Food makeChicken() {System.out.println("我们马上要开始制作鸡肉了");// 如果我们定义这句为核心代码的话,那么,核心代码是真实实现类做的,// 代理只是在核心代码前后做些“无足轻重”的事情Food food = foodService.makeChicken();System.out.println("鸡肉制作完成啦,加点胡椒粉"); // 增强food.addCondiment("pepper");return food;}public Food makeNoodle() {System.out.println("准备制作拉面~");Food food = foodService.makeNoodle();System.out.println("制作完成啦")return food;}
}

客户端调用,注意,我们要用代理来实例化接口:

// 这里用代理类来实例化
FoodService foodService = new FoodServiceProxy();
foodService.makeChicken();

我们发现没有,代理模式说白了就是做 “方法包装” 或做 “方法增强”

在面向切面编程中,其实就是动态代理的过程。比如 Spring 中,我们自己不定义代理类,但是 Spring 会帮我们动态来定义代理,然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中

说到动态代理,可以展开说,Spring 中实现动态代理有两种,JDK动态代理和CGLIB动态代理:

  • 一种是如果我们的类定义了接口,如 UserService 接口和 UserServiceImpl 实现,那么采用 JDK 的动态代理;
  • 另一种是我们自己没有定义接口的,Spring 会采用 CGLIB 进行动态代理,它是一个 jar 包,性能还不错。

Spring的AOP(面向切面编程)是通过代理实现,Spring的代理分为2种:

  1. JDK:默认情况下,当一个类实现了接口,Spring 就会使用JDK代理,但是只代理接口的方法。如果一个对象有其它非接口方法,非接口方法是不会被代理的。
  2. CGLIB:CGLIB底层使用字节码处理框架ASM,来转换字节码并生成新的类;CGLIB代理会创建2个对象,一个是被代理对象,一个是实现了advice(增强逻辑,或切面逻辑)的sub class。所以CGLIB不能代理final修饰的class。

3.2 适配器模式

适配器模式做的就是,有一个接口需要实现,但是我们现成的对象都不满足,需要加一层适配器来进行适配。

适配器模式总体来说分三种:默认适配器模式、对象适配器模式、类适配器模式

先不急着分清楚这几个,先看看例子再说。

3.2.1 默认适配器模式

首先,我们先看看最简单的适配器模式 默认适配器模式(Default Adapter) 是怎么样的。

我们用 Appache commons-io 包中的 FileAlterationListener 做例子,此接口定义了很多的方法,用于对文件或文件夹进行监控,一旦发生了对应的操作,就会触发相应的方法。

public interface FileAlterationListener {void onStart(final FileAlterationObserver observer);void onDirectoryCreate(final File directory);void onDirectoryChange(final File directory);void onDirectoryDelete(final File directory);void onFileCreate(final File file);void onFileChange(final File file);void onFileDelete(final File file);void onStop(final FileAlterationObserver observer);
}

此接口的一大问题是抽象方法太多了,如果我们要用这个接口,意味着我们要实现每一个抽象方法,如果我们只是想要监控文件夹中的文件创建和文件删除事件,可是我们还是不得不实现所有的方法,很明显,这不是我们想要的。

所以,我们需要下面的一个适配器,它用于实现上面的接口,但是所有的方法都是空方法,这样,我们就可以转而定义自己的类来继承下面这个类即可。

public class FileAlterationListenerAdaptor implements FileAlterationListener {public void onStart(final FileAlterationObserver observer) {}public void onDirectoryCreate(final File directory) {}public void onDirectoryChange(final File directory) {}public void onDirectoryDelete(final File directory) {}public void onFileCreate(final File file) {}public void onFileChange(final File file) {}public void onFileDelete(final File file) {}public void onStop(final FileAlterationObserver observer) {}
}

比如我们可以定义以下类,我们仅仅需要实现我们想实现的方法就可以了:

public class FileMonitor extends FileAlterationListenerAdaptor {public void onFileCreate(final File file) {// 文件创建doSomething();}public void onFileDelete(final File file) {// 文件删除doSomething();}
}

当然,上面说的只是适配器模式的其中一种,也是最简单的一种,无需多言。下面,再介绍“正统的”适配器模式。

3.2.2 对象适配器模式

来看一个《Head First 设计模式》中的一个例子,稍微修改了一下,看看怎么将鸡适配成鸭,这样鸡也能当鸭来用。因为,现在鸭这个接口,我们没有合适的实现类可以用,所以需要适配器。

public interface Duck {public void quack(); // 鸭的呱呱叫public void fly(); // 飞
}public interface Cock {public void gobble(); // 鸡的咕咕叫public void fly(); // 飞
}public class WildCock implements Cock {public void gobble() {System.out.println("咕咕叫");}public void fly() {System.out.println("鸡也会飞哦");}
}

鸭接口有 fly() 和 quare() 两个方法,鸡 Cock 如果要冒充鸭,fly() 方法是现成的,但是鸡不会鸭的呱呱叫,没有 quack() 方法。这个时候就需要适配了:

// 毫无疑问,首先,这个适配器肯定需要 implements Duck,这样才能当做鸭来用
public class CockAdapter implements Duck {Cock cock;// 构造方法中需要一个鸡的实例,此类就是将这只鸡适配成鸭来用public CockAdapter(Cock cock) {this.cock = cock;}// 实现鸭的呱呱叫方法@Overridepublic void quack() {// 内部其实是一只鸡的咕咕叫cock.gobble();}@Overridepublic void fly() {cock.fly();}
}

客户端调用很简单了:

public static void main(String[] args) {// 有一只野鸡Cock wildCock = new WildCock();// 成功将野鸡适配成鸭Duck duck = new CockAdapter(wildCock);...
}

到这里,大家也就知道了适配器模式是怎么回事了。无非是我们需要一只鸭,但是我们只有一只鸡,这个时候就需要定义一个适配器,由这个适配器来充当鸭,但是适配器里面的方法还是由鸡来实现的。

我们用一个图来简单说明下:

3.2.3 类适配器模式

直接上图:

看到这个图,大家应该很容易理解的吧,通过继承的方法,适配器自动获得了所需要的大部分方法。这个时候,客户端使用更加简单,直接 Target t = new SomeAdapter(); 就可以了。

3.2.4 适配器模式总结

类适配和对象适配的异同:

  • 一个采用继承,一个采用组合
  • 类适配属于静态实现,对象适配属于组合的动态实现,对象适配需要多实例化一个对象
  • 总体来说,对象适配用得比较多。

适配器模式和代理模式的异同:

比较这两种模式,其实是比较对象适配器模式和代理模式,在代码结构上,它们很相似,都需要一个具体的实现类的实例。

但是它们的目的不一样,代理模式做的是增强原方法的活适配器做的是适配的活,为的是提供“把鸡包装成鸭,然后当做鸭来使用”,而鸡和鸭它们之间原本没有继承关系

3.3 桥梁模式

理解桥梁模式,其实就是理解代码抽象和解耦

我们首先需要一个桥梁,它是一个接口,定义提供的接口方法。

public interface DrawAPI {public void draw(int radius, int x, int y);
}

然后是一系列实现类:

public class RedPen implements DrawAPI {@Overridepublic void draw(int radius, int x, int y) {System.out.println("用红色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);}
}
public class GreenPen implements DrawAPI {@Overridepublic void draw(int radius, int x, int y) {System.out.println("用绿色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);}
}
public class BluePen implements DrawAPI {@Overridepublic void draw(int radius, int x, int y) {System.out.println("用蓝色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);}
}

定义一个抽象类,此类的实现类都需要使用 DrawAPI:

public abstract class Shape {protected DrawAPI drawAPI;protected Shape(DrawAPI drawAPI) {this.drawAPI = drawAPI;}public abstract void draw();
}

定义抽象类的子类:

// 圆形
public class Circle extends Shape {private int radius;public Circle(int radius, DrawAPI drawAPI) {super(drawAPI);this.radius = radius;}public void draw() {drawAPI.draw(radius, 0, 0);}
}
// 长方形
public class Rectangle extends Shape {private int x;private int y;public Rectangle(int x, int y, DrawAPI drawAPI) {super(drawAPI);this.x = x;this.y = y;}public void draw() {drawAPI.draw(0, x, y);}
}

最后,我们来看客户端演示:

public static void main(String[] args) {Shape greenCircle = new Circle(10, new GreenPen());Shape redRectangle = new Rectangle(4, 8, new RedPen());greenCircle.draw();redRectangle.draw();
}

可能大家看上面一步步还不是特别清晰,我把所有的东西整合到一张图上:

这回大家应该就知道抽象在哪里,怎么解耦了吧。桥梁模式的优点也是显而易见的,就是非常容易进行扩展。

3.4 装饰模式

要把装饰模式说清楚明白,不是件容易的事情。也许读者知道 Java IO 中的几个类是典型的装饰模式的应用,但是读者不一定清楚其中的关系,也许看完就忘了,希望看完这节后,读者可以对其有更深的感悟。

首先,我们先看一个简单的图,看这个图的时候,了解下层次结构就可以了:

我们来说说装饰模式的出发点,从图中可以看到,接口 Component 其实已经有了 ConcreteComponentA 和 ConcreteComponentB 两个实现类了,但是,如果我们要增强这两个实现类的话,我们就可以采用装饰模式,用具体的装饰器来装饰实现类,以达到增强的目的。

从名字来简单解释下装饰器。既然说是装饰,那么往往就是添加小功能这种,而且,我们要满足可以添加多个小功能。最简单的,代理模式就可以实现功能的增强,但是代理不容易实现多个功能的增强,当然你可以说用代理包装代理的多层包装方式,但是那样的话代码就复杂了

首先明白一些简单的概念,从图中我们看到,所有的具体装饰者们 ConcreteDecorator* 都可以作为 Component 来使用,因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent* 的区别是,它们只是装饰者,起装饰作用,也就是即使它们看上去牛逼轰轰,但是它们都只是在具体的实现中加了层皮来装饰而已。

下面来看看一个例子,先把装饰模式弄清楚,然后再介绍下 java io 中的装饰模式的应用。

大街上流行起来了“快乐柠檬”,我们把快乐柠檬的饮料分为三类:红茶、绿茶、咖啡,在这三大类的基础上,又增加了许多的口味,什么金桔柠檬红茶、金桔柠檬珍珠绿茶、芒果红茶、芒果绿茶、芒果珍珠红茶、烤珍珠红茶、烤珍珠芒果绿茶、椰香胚芽咖啡、焦糖可可咖啡等等,每家店都有很长的菜单,但是仔细看下,其实原料也没几样,但是可以搭配出很多组合,如果顾客需要,很多没出现在菜单中的饮料他们也是可以做的。

在这个例子中,红茶、绿茶、咖啡是最基础的饮料,其他的像金桔柠檬、芒果、珍珠、椰果、焦糖等都属于装饰用的。当然,在开发中,我们确实可以像门店一样,开发这些类:LemonBlackTea、LemonGreenTea、MangoBlackTea、MangoLemonGreenTea......但是,很快我们就发现,这样子干肯定是不行的,这会导致我们需要组合出所有的可能,而且如果客人需要在红茶中加双份柠檬怎么办?三份柠檬怎么办?

不说废话了,上代码。 首先,定义饮料抽象基类:

public abstract class Beverage {// 返回描述public abstract String getDescription();// 返回价格public abstract double cost();
}

然后是三个基础饮料实现类,红茶、绿茶和咖啡:

public class BlackTea extends Beverage {public String getDescription() {return "红茶";}public double cost() {return 10;}
}
public class GreenTea extends Beverage {public String getDescription() {return "绿茶";}public double cost() {return 11;}
}
...// 咖啡省略

定义调料,也就是装饰者的基类,此类必须继承自 Beverage:

// 调料
public abstract class Condiment extends Beverage {
}

然后我们来定义柠檬、芒果等具体的调料,它们属于装饰者,毫无疑问,这些调料肯定都需要继承调料 Condiment 类:

public class Lemon extends Condiment {private Beverage bevarage;// 这里很关键,需要传入具体的饮料,如需要传入没有被装饰的红茶或绿茶,// 当然也可以传入已经装饰好的芒果绿茶,这样可以做芒果柠檬绿茶public Lemon(Beverage bevarage) {this.bevarage = bevarage;}public String getDescription() {// 装饰return bevarage.getDescription() + ", 加柠檬";}public double cost() {// 装饰return beverage.cost() + 2; // 加柠檬需要 2 元}
}public class Mango extends Condiment {private Beverage bevarage;public Mango(Beverage bevarage) {this.bevarage = bevarage;}public String getDescription() {return bevarage.getDescription() + ", 加芒果";}public double cost() {return beverage.cost() + 3; // 加芒果需要 3 元}
}
...// 给每一种调料都加一个类

看客户端调用:

public static void main(String[] args) {// 首先,我们需要一个基础饮料,红茶、绿茶或咖啡Beverage beverage = new GreenTea();// 开始装饰beverage = new Lemon(beverage); // 先加一份柠檬beverage = new Mongo(beverage); // 再加一份芒果System.out.println(beverage.getDescription() + " 价格:¥" + beverage.cost());//"绿茶, 加柠檬, 加芒果 价格:¥16"
}

如果我们需要芒果-珍珠-双份柠檬-红茶:

Beverage beverage = new Mongo(new Pearl(new Lemon(new Lemon(new BlackTea())))); 

看看下图可能会清晰一些:

到这里,大家应该已经清楚装饰模式了吧。

下面,我们再来说说 Java IO 中的装饰模式。看下图 InputStream 派生出来的部分类:

我们知道 InputStream 代表了输入流,具体的输入来源可以是文件(FileInputStream)、管道(PipedInputStream)、数组(ByteArrayInputStream)等,这些就像前面奶茶的例子中的红茶、绿茶,属于基础输入流。

FilterInputStream 承接了装饰模式的关键节点,它的实现类是一系列装饰器,比如 BufferedInputStream 代表用缓冲来装饰,也就使得输入流具有了缓冲的功能,LineNumberInputStream 代表用行号来装饰,在操作的时候就可以取得行号了,DataInputStream 的装饰,使得我们可以从输入流转换为 Java 中的基本类型值。

当然,在 Java IO 中,如果我们使用装饰器的话,就不太适合面向接口编程了,如:

InputStream inputStream = new LineNumberInputStream(new BufferedInputStream(new FileInputStream("")));

这样的结果是,InputStream 还是不具有读取行号的功能,因为读取行号的方法定义在 LineNumberInputStream 类中。

我们应该像下面这样使用:

DataInputStream is = new DataInputStream(new BufferedInputStream(new FileInputStream("")));

所以要找到纯的严格符合设计模式的代码还是比较难的。

3.4 门面模式

门面模式(也叫外观模式,Facade Pattern)在许多源码中有使用,比如 SLF4J 就可以理解为是门面模式的应用。这是一个简单的设计模式,我们直接上代码再说吧。

首先,我们定义一个接口:

public interface Shape {void draw();
}

定义几个实现类:

public class Circle implements Shape {@Overridepublic void draw() {System.out.println("Circle::draw()");}
}
public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Rectangle::draw()");}
}

客户端调用:

public static void main(String[] args) {// 画一个圆形Shape circle = new Circle();circle.draw();// 画一个长方形Shape rectangle = new Rectangle();rectangle.draw();
}

以上是我们常写的代码,我们需要画圆就要先实例化圆,画长方形就需要先实例化一个长方形,然后再调用相应的 draw() 方法。

下面,我们看看怎么用门面模式来让客户端调用更加友好一些。

我们先定义一个门面:

public class ShapeMaker {private Shape circle;private Shape rectangle;private Shape square;public ShapeMaker() {circle = new Circle();rectangle = new Rectangle();square = new Square();}/*** 下面定义一堆方法,具体应该调用什么方法,由这个门面来决定*/public void drawCircle(){circle.draw();}public void drawRectangle(){rectangle.draw();}public void drawSquare(){square.draw();}
}

看看现在客户端怎么调用:

public static void main(String[] args) {ShapeMaker shapeMaker = new ShapeMaker();// 客户端调用现在更加清晰了shapeMaker.drawCircle();shapeMaker.drawRectangle();shapeMaker.drawSquare();        
}

门面模式的优点显而易见,客户端不再需要关注实例化时应该使用哪个实现类,直接调用门面提供的方法就可以了,因为门面类提供的方法的方法名对于客户端来说已经很友好了。

3.5 组合模式

组合模式用于表示具有层次结构的数据,使得我们对单个对象和组合对象的访问具有一致性。

举例:每个员工都有姓名、部门、薪水这些属性,同时还有下属员工集合(虽然可能集合为空),而下属员工和自己的结构是一样的,也有姓名、部门这些属性,同时也有他们的下属员工集合。

public class Employee {private String name;private String dept;private int salary;private List<Employee> subordinates; // 下属public Employee(String name,String dept, int sal) {this.name = name;this.dept = dept;this.salary = sal;subordinates = new ArrayList<Employee>();}public void add(Employee e) {subordinates.add(e);}public void remove(Employee e) {subordinates.remove(e);}public List<Employee> getSubordinates(){return subordinates;}public String toString(){return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary+" ]");}   
}

通常,这种类需要定义 add(node)、remove(node)、getChildren() 这些方法。

这说的其实就是组合模式,这种简单的模式我就不做过多介绍了。

3.6 享元模式

英文是 Flyweight Pattern,我们试着强行关联起来吧。Flyweight 是轻量级的意思,享元分开来说就是 共享 元器件,也就是复用已经生成的对象,这种做法当然也就是轻量级的了。

复用对象最简单的方式是,用一个 HashMap 来存放每次新生成的对象。每次需要一个对象的时候,先到 HashMap 中看看有没有,如果没有,再生成新的对象,然后将这个对象放入 HashMap 中。

享元模式是池技术的重要实现方式,其定义如下:使用共享对象可以有效地支持 大量的细粒度的对象。它的主要目的是通过共享对象来减少系统种对象的数量,其本质就是缓存共享对象,降低内存消耗

代码比较简单,就不演示了。

3.7 结构型模式总结

  • 代理模式是做方法增强的;
  • 适配器模式是把鸡包装成鸭这种用来适配接口的;
  • 桥梁模式做到了很好的解耦;
  • 装饰模式从名字上就看得出来,适合于装饰类或者说是增强类的场景;
  • 门面模式的优点是客户端不需要关心实例化过程,只要调用需要的方法即可;
  • 组合模式用于描述具有层次结构的数据;
  • 享元模式是为了在特定的场景中缓存已经创建的对象,用于提高性能。

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

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

相关文章

openrtp 音视频时间戳问题

解决音视频发送的rtp问题 openrtp增加了音频aac的发送&#xff0c;地址 OpenRTP Gitee开源地址 同时使用两个rtp &#xff0c;来发送音频和视频 使用以下音频rtp&#xff0c;是可以发送和接收的&#xff0c;音频端口在视频端口上2 v0 o- 0 0 IN IP4 127.0.0.1 sMy Stream cI…

Windows通过netsh控制安全中心防火墙和网络保护策略

Windows通过netsh控制安全中心防火墙和网络保护策略 1. 工具简介 【1】. Windows安全中心 【2】. netsh工具 netsh(Network Shell) 是一个Windows系统本身提供的功能强大的网络配置命令行工具。 2. 开启/关闭防火墙策略 在设置端口&#xff08;禁用/启用&#xff09;前&am…

使用 CDN 后 Apache 的日志记录客户真实 IP

经常搭建网站服务器的都知道&#xff0c;在给站点使用了 CDN 后 Web 应用的日志记录里就会只记录 CDN 节点 IP 了&#xff0c;这就没法看到真实客户请求 IP&#xff0c;对于日志分析、运维日常维护来说就有点儿麻烦了&#xff0c;今天明月结合在五洛云服务器上搭建的Apache环境…

多ip访问多网站

多IP访问多网站 1.预配操作 [rootlocalhost ~]# mount /dev/sr0 /mnt mount: /mnt: WARNING: source write-protected, mounted read-only. [rootlocalhost ~]# systemctl stop firewalld ----------关闭防火墙 [rootlocalhost ~]# setenforce 0 -------关闭selinux2.安装n…

【论文阅读】ESRGAN

学习资料 论文题目:增强型超分辨率生成对抗网络(ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks)论文地址:[1809.00219] ESRGAN:增强型超分辨率生成对抗网络代码:xinntao / ESRGAN:ECCV18 研讨会 - 增强的 SRGAN。Champion PIRM Challenge 关于感知…

【机器学习】VQ-VAE(Vector Quantized Variational Autoencoder)

VQ-VAE&#xff08;Vector Quantized Variational Autoencoder&#xff09;是一种生成模型&#xff0c;它结合了变分自编码器&#xff08;Variational Autoencoder, VAE&#xff09;和向量量化&#xff08;Vector Quantization&#xff09;技术。VQ-VAE的主要目的在于通过离散潜…

【动态规划】子序列问题(上)

1. 最长递增子序列 300. 最长递增子序列 和子数组不同的是&#xff0c;子数组要求是连续的&#xff0c;子序列只要下标是递增的就可以&#xff0c;这里严格递增的意思是不能有相等的元素&#xff0c;必须一直递增 状态表示&#xff1a;以 i 位置为结尾的所有的子序列中最长递…

Android GPU Inspector分析帧数据快速入门

使用 谷歌官方工具Android GPU Inspector (AGI) 可以对Android 应用进行深入和全面的系统性能分析和帧性能分析 。AGI 是一个非常强大的分析工具&#xff0c;尤其是在需要诊断 GPU 性能问题和优化应用时&#xff0c;可以帮助你精准找到性能瓶颈。本文介绍如何使用该工具对帧数据…

梳理一下spring中,与message相关的知识点

本次梳理的相关知识点包括jms&#xff0c;amqp(rabbitmq)&#xff0c;sping-messaging&#xff0c;spring-integration&#xff0c;springcloud-stream&#xff0c;这些都是与消息message相关的内容&#xff0c;它们有什么区别与联系呢&#xff1f; 相关的要点与相互关系都整理…

物联网消息队列Emqx日志配置及日志追踪以及Centos7上的rc.local开机不执行、git提交的小问题

一、物联网消息队列Emqx日志配置及日志追踪 EMQX支持将日志输出到控制台或者日志文件&#xff0c;或者同时使用两者。使用 Docker 部署 EMQX&#xff0c;默认只能通过 docker logs 命令查看 EMQX 日志。EMQX 的默认日志级别为 warning&#xff0c;默认在单日志文件超过10MB(log…

word压缩大小怎么弄?快来试试这几种压缩word方法!

word压缩大小怎么弄&#xff1f;在处理Word文档时&#xff0c;如果遇到体积过大的情况&#xff0c;无疑会带来一系列麻烦&#xff0c;大型Word文档不仅占据大量存储空间&#xff0c;而且在传输过程中会耗费更多时间&#xff0c;想象一下&#xff0c;当你急需将一份重要的文档发…

Perl打印9x9乘法口诀

本章教程主要介绍如何用Perl打印9x9乘法口诀。 一、程序代码 1、写法① use strict; # 启用严格模式&#xff0c;帮助捕捉变量声明等错误 use warnings; # 启用警告&#xff0c;帮助发现潜在问题# 遍历 1 到 9 的数字 for my $i (1..9) {# 对于每个 $i&#xff0c;遍历 1…

【设计模式系列】观察者模式

一、什么是观察者模式 观察者模式&#xff08;Observer Pattern&#xff09;是一种行为设计模式&#xff0c;它定义了对象之间的一对多依赖关系&#xff0c;当一个对象的状态发生变化时&#xff0c;所有依赖于它的对象都会得到通知并自动更新。这种模式也被称为发布-订阅模式&…

【AscendC算子开发】笔记2 算子高级开发和调试调优

算子调试 Tensor也可以通过特定的printf方法来打印&#xff0c;见上图。 gdb调试见上图。 为什么gdb调试无法成功&#xff0c;因为run.sh里面有两行export&#xff0c;如果直接通过.XX运行的话需要配置一下。 npu域也支持调试&#xff0c;可以使用上述的方法。 内存检测工…

AI自动生成PPT哪个软件好?智能生成PPT不再熬夜做课件

大概这世上&#xff0c;都是职场牛马对“PPT”这三个字母的头痛反应最大吧&#xff01; 是的&#xff0c;就连各个年级段的老师也是很头痛——愁着怎样能在排版整齐的情况下&#xff0c;将必考知识点都呈现在PPT每一张幻灯片页面里...... 近期打听到用人工智能生成ppt课件&am…

ProtoBuf 的含义和安装

ProtoBuf 是什么 Protocol Buffers 是 Google 的⼀种语⾔⽆关、平台⽆关、可扩展的序列化结构数据的⽅法&#xff0c;它可⽤ 于&#xff08;数据&#xff09;通信协议、数据存储等。 Protocol Buffers 类⽐于、 XML&#xff0c;是⼀种灵活&#xff0c;⾼效&#xff0c;⾃动化机…

Java项目-基于springboot框架的智慧外贸系统项目实战(附源码+文档)

作者&#xff1a;计算机学长阿伟 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、ElementUI等&#xff0c;“文末源码”。 开发运行环境 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringBoot、Vue、Mybaits Plus、ELementUI工具&#xff1a;IDEA/…

2024年最新苹果iOS证书申请创建App详细图文流程

iOS 证书设置指南&#xff1a; 对于开发者来说&#xff0c;在没有Mac电脑或对Xcode等开发工具不熟悉的情况下&#xff0c;如何快速完成IOS证书制作和IPA文件提交至开发者中心一直是一个难题。但是现在&#xff0c;有了初雪云提供的极简工具&#xff0c;您可以轻松实现这两个任…

Tomcat隐藏版本号和报错信息

为了避免漏洞扫描的时候造成版本泄露&#xff0c;可以在conf/server.xml配置文件中的<Host>配置项中添加如下配置: <Valve className"org.apache.catalina.valves.ErrorReportValve" showReport"false" showServerInfo"false" /> …

c语言内核链表

c语言内核链表 在Linux中拥有大量的内核源码&#xff0c;在数据存储的这块位置拥有内核链表&#xff08;双向循环链表&#xff09; 由linux内核提供的链表文件&#xff0c;里面包含了多组内联函数和宏定义函数以及功能性函数。 内核链表中定义了多个函数&#xff0c;我们只需要…