瑞_23种设计模式_享元模式

文章目录

    • 1 享元模式（Flyweight Pattern）
      • 1.1 介绍
      • 1.2 概述
      • 1.3 享元模式的结构
      • 1.4 享元模式的优缺点
      • 1.5 享元模式的使用场景
    • 2 案例一
      • 2.1 需求
      • 2.2 代码实现
    • 3 案例二
      • 3.1 需求
      • 3.2 代码实现
    • 4 JDK源码解析（Integer类）

🙊 前言：本文章为瑞_系列专栏之《23种设计模式》的享元模式篇。本文中的部分图和概念等资料，来源于博主学习设计模式的相关网站《菜鸟教程 | 设计模式》和《黑马程序员Java设计模式详解》，特此注明。本文中涉及到的软件设计模式的概念、背景、优点、分类、以及UML图的基本知识和设计模式的6大法则等知识，建议阅读 《瑞_23种设计模式_概述》

本系列 - 设计模式 - 链接：《瑞_23种设计模式_概述》

⬇️本系列 - 创建型模式 - 链接🔗

  单例模式：《瑞_23种设计模式_单例模式》
  工厂模式：《瑞_23种设计模式_工厂模式》
  原型模式：《瑞_23种设计模式_原型模式》
抽象工厂模式：《瑞_23种设计模式_抽象工厂模式》
 建造者模式：《瑞_23种设计模式_建造者模式》

⬇️本系列 - 结构型模式 - 链接🔗

  代理模式：《瑞_23种设计模式_代理模式》
 适配器模式：《瑞_23种设计模式_适配器模式》
 装饰者模式：《瑞_23种设计模式_装饰者模式》
  桥接模式：《瑞_23种设计模式_桥接模式》
  外观模式：《瑞_23种设计模式_外观模式》
  组合模式：《瑞_23种设计模式_组合模式》
  享元模式：《后续更新》

⬇️本系列 - 行为型模式 - 链接🔗

模板方法模式：《后续更新》
  策略模式：《后续更新》
  命令模式：《后续更新》
 职责链模式：《后续更新》
  状态模式：《后续更新》
 观察者模式：《后续更新》
 中介者模式：《后续更新》
 迭代器模式：《后续更新》
 访问者模式：《后续更新》
 备忘录模式：《后续更新》
 解释器模式：《后续更新》

在这里插入图片描述

1 享元模式（Flyweight Pattern）

  享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

瑞：结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。

  享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。

1.1 介绍

  • 意图：运用共享技术有效地支持大量细粒度的对象。

  • 主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

  • 何时使用：
      1️⃣ 系统中有大量对象。
      2️⃣ 这些对象消耗大量内存。
      3️⃣ 这些对象的状态大部分可以外部化。
      4️⃣ 这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替。
      5️⃣ 系统不依赖于这些对象身份，这些对象是不可分辨的。

  • 如何解决：用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。

  • 关键代码：用 HashMap 存储这些对象。

  • 应用实例：
      1️⃣ JAVA 中的 String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面。
      2️⃣ 数据库的连接池。

  • 优点：大大减少对象的创建，降低系统的内存，使效率提高。

  • 缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

  • 使用场景：
      1️⃣ 系统有大量相似对象。
      2️⃣ 需要缓冲池的场景。

  • 注意事项：
      1️⃣ 注意划分外部状态和内部状态，否则可能会引起线程安全问题。
      2️⃣ 这些类必须有一个工厂对象加以控制。

1.2 概述

定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率。

  • 享元（Flyweight ）模式中存在以下两种状态：
      1️⃣ 内部状态，即不会随着环境的改变而改变的可共享部分。
      2️⃣ 外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

1.3 享元模式的结构

  • 享元模式的主要有以下角色：
      1️⃣ 抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
      2️⃣ 具体享元（Concrete Flyweight）角色 ：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
      3️⃣ 非享元（Unsharable Flyweight)角色 ：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
      4️⃣ 享元工厂（Flyweight Factory）角色 ：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

1.4 享元模式的优缺点

  优点：
  1️⃣ 极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
  2️⃣ 享元模式中的外部状态相对独立，且不影响内部状态

  缺点：
  1️⃣ 为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

1.5 享元模式的使用场景

  • 一个系统有大量相同或者相似的对象，造成内存的大量耗费。
  • 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
  • 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。


2 案例一

【案例】俄罗斯方块

2.1 需求

  下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。

在这里插入图片描述

  类图设计如下：

在这里插入图片描述

2.2 代码实现

俄罗斯方块有不同的形状，我们可以对这些形状向上抽取出AbstractBox，用来定义共性的属性和行为。

抽象享元角色（抽象类） 
/**
 * 抽象享元角色
 *
 * @author LiaoYuXing-Ray
 **/
public abstract class AbstractBox {

    // 获取图形的方法
    public abstract String getShape();

    // 显示图形及颜色
    public void display(String color) {
        System.out.println("方块形状：" + getShape() + ", 颜色：" + color);
    }
}

接下来就是定义不同的形状了，IBox类、LBox类、OBox类等。

I图形类(具体享元角色)（类） 
/**
 * I图形类(具体享元角色)
 *
 * @author LiaoYuXing-Ray
 **/
public class IBox extends AbstractBox {

    public String getShape() {
        return "I";
    }
}
L图形类(具体享元角色)（类） 
/**
 * L图形类(具体享元角色)
 *
 * @author LiaoYuXing-Ray
 **/
public class LBox extends AbstractBox {

    public String getShape() {
        return "L";
    }
}
O图形类(具体享元角色)（类） 
/**
 * O图形类(具体享元角色)
 *
 * @author LiaoYuXing-Ray
 **/
public class OBox extends AbstractBox {

    public String getShape() {
        return "O";
    }
}

提供了一个工厂类（BoxFactory），用来管理享元对象（也就是AbstractBox子类对象），该工厂类对象只需要一个，所以可以使用单例模式。并给工厂类提供一个获取形状的方法。

工厂类（类） 

import java.util.HashMap;


/**
 * 工厂类，将该类设计为单例
 *
 * @author LiaoYuXing-Ray
 **/
public class BoxFactory {

    private final HashMap<String, AbstractBox> map;

    // 在构造方法中进行初始化操作
    private BoxFactory() {
        map = new HashMap<String, AbstractBox>();
        map.put("I",new IBox());
        map.put("L",new LBox());
        map.put("O",new OBox());
    }

    // 提供一个方法获取该工厂类对象
    public static BoxFactory getInstance() {
        return factory;
    }

    private static final BoxFactory factory = new BoxFactory();

    // 根据名称获取图形对象
    public AbstractBox getShape(String name) {
        return map.get(name);
    }
}
测试类 
/**
 * 测试类
 *
 * @author LiaoYuXing-Ray
 **/
public class Client {
    public static void main(String[] args) {
        // 获取I图形对象
        AbstractBox box1 = BoxFactory.getInstance().getShape("I");
        box1.display("灰色");

        // 获取L图形对象
        AbstractBox box2 = BoxFactory.getInstance().getShape("L");
        box2.display("绿色");

        // 获取O图形对象
        AbstractBox box3 = BoxFactory.getInstance().getShape("O");
        box3.display("灰色");

        // 获取O图形对象
        AbstractBox box4 = BoxFactory.getInstance().getShape("O");
        box4.display("红色");

        System.out.println("两次获取到的O图形对象是否是同一个对象：" + (box3 == box4));
    }
}

  代码运行结果如下：

	方块形状：I, 颜色：灰色
	方块形状：L, 颜色：绿色
	方块形状：O, 颜色：灰色
	方块形状：O, 颜色：红色
	两次获取到的O图形对象是否是同一个对象：true


3 案例二

本案例为菜鸟教程中的案例

3.1 需求

  我们将通过创建 5 个对象来画出 20 个分布于不同位置的圆来演示这种模式。由于只有 5 种可用的颜色，所以 color 属性被用来检查现有的 Circle 对象。

  我们将创建一个 Shape 接口和实现了 Shape 接口的实体类 Circle。下一步是定义工厂类 ShapeFactory。

  ShapeFactory 有一个 Circle 的 HashMap，其中键名为 Circle 对象的颜色。无论何时接收到请求，都会创建一个特定颜色的圆。ShapeFactory 检查它的 HashMap 中的 circle 对象，如果找到 Circle 对象，则返回该对象，否则将创建一个存储在 hashmap 中以备后续使用的新对象，并把该对象返回到客户端。

  FlyWeightPatternDemo 类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（red / green / blue/ black / white），以便获取它所需对象的颜色。

在这里插入图片描述

3.2 代码实现

步骤 1

  创建一个接口。

Shape.java 
public interface Shape {
   void draw();
}

步骤 2

  创建实现接口的实体类。

Circle.java 
public class Circle implements Shape {
   private String color;
   private int x;
   private int y;
   private int radius;
 
   public Circle(String color){
      this.color = color;     
   }
 
   public void setX(int x) {
      this.x = x;
   }
 
   public void setY(int y) {
      this.y = y;
   }
 
   public void setRadius(int radius) {
      this.radius = radius;
   }
 
   @Override
   public void draw() {
      System.out.println("Circle: Draw() [Color : " + color 
         +", x : " + x +", y :" + y +", radius :" + radius);
   }
}

步骤 3

  创建一个工厂，生成基于给定信息的实体类的对象。

ShapeFactory.java 
import java.util.HashMap;
 
public class ShapeFactory {
   private static final HashMap<String, Shape> circleMap = new HashMap<>();
 
   public static Shape getCircle(String color) {
      Circle circle = (Circle)circleMap.get(color);
 
      if(circle == null) {
         circle = new Circle(color);
         circleMap.put(color, circle);
         System.out.println("Creating circle of color : " + color);
      }
      return circle;
   }
}

步骤 4

  使用该工厂，通过传递颜色信息来获取实体类的对象。

FlyweightPatternDemo.java 
public class FlyweightPatternDemo {
   private static final String colors[] = 
      { "Red", "Green", "Blue", "White", "Black" };
   public static void main(String[] args) {
 
      for(int i=0; i < 20; ++i) {
         Circle circle = 
            (Circle)ShapeFactory.getCircle(getRandomColor());
         circle.setX(getRandomX());
         circle.setY(getRandomY());
         circle.setRadius(100);
         circle.draw();
      }
   }
   private static String getRandomColor() {
      return colors[(int)(Math.random()*colors.length)];
   }
   private static int getRandomX() {
      return (int)(Math.random()*100 );
   }
   private static int getRandomY() {
      return (int)(Math.random()*100);
   }
}

步骤 5

  执行程序，输出结果：

	Creating circle of color : Black
	Circle: Draw() [Color : Black, x : 36, y :71, radius :100
	Creating circle of color : Green
	Circle: Draw() [Color : Green, x : 27, y :27, radius :100
	Creating circle of color : White
	Circle: Draw() [Color : White, x : 64, y :10, radius :100
	Creating circle of color : Red
	Circle: Draw() [Color : Red, x : 15, y :44, radius :100
	Circle: Draw() [Color : Green, x : 19, y :10, radius :100
	Circle: Draw() [Color : Green, x : 94, y :32, radius :100
	Circle: Draw() [Color : White, x : 69, y :98, radius :100
	Creating circle of color : Blue
	Circle: Draw() [Color : Blue, x : 13, y :4, radius :100
	Circle: Draw() [Color : Green, x : 21, y :21, radius :100
	Circle: Draw() [Color : Blue, x : 55, y :86, radius :100
	Circle: Draw() [Color : White, x : 90, y :70, radius :100
	Circle: Draw() [Color : Green, x : 78, y :3, radius :100
	Circle: Draw() [Color : Green, x : 64, y :89, radius :100
	Circle: Draw() [Color : Blue, x : 3, y :91, radius :100
	Circle: Draw() [Color : Blue, x : 62, y :82, radius :100
	Circle: Draw() [Color : Green, x : 97, y :61, radius :100
	Circle: Draw() [Color : Green, x : 86, y :12, radius :100
	Circle: Draw() [Color : Green, x : 38, y :93, radius :100
	Circle: Draw() [Color : Red, x : 76, y :82, radius :100
	Circle: Draw() [Color : Blue, x : 95, y :82, radius :100


4 JDK源码解析（Integer类）

  Integer类使用了享元模式。我们先看下面的例子：

public class Demo {
    public static void main(String[] args) {
        Integer i1 = 127;
        Integer i2 = 127;

        System.out.println("i1和i2对象是否是同一个对象？" + (i1 == i2));

        Integer i3 = 128;
        Integer i4 = 128;

        System.out.println("i3和i4对象是否是同一个对象？" + (i3 == i4));
    }
}

  代码运行结果如下：

	i1和i2对象是否是同一个对象？true
	i3和i4对象是否是同一个对象？false

为什么第一个输出语句输出的是true，第二个输出语句输出的是false？

  通过反编译软件进行反编译，代码如下：

public class Demo {
    public static void main(String[] args) {
        Integer i1 = Integer.valueOf((int)127);
        Integer i2 Integer.valueOf((int)127);
        System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());
        Integer i3 = Integer.valueOf((int)128);
        Integer i4 = Integer.valueOf((int)128);
        System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());
    }
}

  上面代码可以看到，直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是 valueOf() ，所以只需要看该方法即可

public final class Integer extends Number implements Comparable<Integer> {
    
	public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                }
            }
            high = h;
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }
}

可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创建一个新的 Integer 对象。



本文是博主的粗浅理解，可能存在一些错误或不完善之处，如有遗漏或错误欢迎各位补充，谢谢

  如果觉得这篇文章对您有所帮助的话，请动动小手点波关注💗，你的点赞👍收藏⭐️转发🔗评论📝都是对博主最好的支持~


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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

公园常见污水处理需要哪些设备

公园常见污水处理需要哪些设备

根据我了解的情况&#xff0c;公园常见的污水处理需要以下几种设备&#xff1a; 1、格栅机&#xff1a;格栅机是污水处理的第一道工序&#xff0c;用于过滤掉污水中的大颗粒杂物和固体废物&#xff0c;防止其进入后续处理装置。 2、沉淀池&#xff1a;沉淀池用于将污水中的悬浮…
阅读更多...
Platformview在iOS与Android上的实现方式对比

Platformview在iOS与Android上的实现方式对比

Android中早期版本Platformview的实现基于Virtual Display。VirtualDisplay方案的原理是&#xff0c;先将Native View绘制到虚显&#xff0c;然后Flutter通过从虚显输出中获取纹理并将其与自己内部的widget树进行合成&#xff0c;最后作为Flutter在 Android 上更大的纹理输出的…
阅读更多...
MySQL·SQL优化

MySQL·SQL优化

目录 一 . 前言 二 . 优化方法 1 . 索引 &#xff08;1&#xff09;数据构造 &#xff08;2&#xff09;单索引 &#xff08;3&#xff09;explain &#xff08;4&#xff09;组合索引 &#xff08;5&#xff09;索引总结 2 . 避免使用select * 3 . 用union all代替u…
阅读更多...
前端小案例——登录界面（正则验证, 附源码）

前端小案例——登录界面（正则验证, 附源码）

一、前言 实现功能&#xff1a; 提供用户名和密码输入框。当用户提交表单时&#xff0c;阻止默认提交行为。使用正则表达式验证用户输入的内容&#xff0c;判断输入的是有效的邮箱地址还是身份证号码。根据验证结果&#xff0c;在输入框下方显示相应的提示信息。 实现逻辑&a…
阅读更多...
注意力机制（代码实现案例)

注意力机制（代码实现案例)

学习目标 了解什么是注意力计算规则以及常见的计算规则.了解什么是注意力机制及其作用.掌握注意力机制的实现步骤. 1 注意力机制介绍 1.1 注意力概念 我们观察事物时&#xff0c;之所以能够快速判断一种事物(当然允许判断是错误的), 是因为我们大脑能够很快把注意力放在事物…
阅读更多...
docker快照备份回滚

docker快照备份回滚

1. 安装系统 1.1 vm安装Ubuntu 参考:https://blog.csdn.net/u010308917/article/details/125157774 1.2 其他操作 添加自定义物理卷 –待补充– 1.2.1 查询可用物理卷 fdisk -l 输出如下 Disk /dev/loop0: 73.9 MiB, 77492224 bytes, 151352 sectors Units: sectors of …
阅读更多...
运维随录实战（4）

运维随录实战（4）

添加账号并为账号赋予root权限 1，使用root账号添加一个普通账号 adduser test passwd test # 赋予密码 2，赋予root权限 修改/etc/sudoers文件，如果使用vi 命令打开提示仅只读，则使用 visudo命令打开 在root下面添加一行“test ALL=(ALL) ALL”，如下所示 3，将test账…
阅读更多...
【MySQL使用】show processlist 命令详解

【MySQL使用】show processlist 命令详解

show processlist 命令详解 一、命令含义二、命令返回参数三、Command值解释四、State值解释五、参考资料 一、命令含义 对于一个MySQL连接&#xff0c;或者说一个线程&#xff0c;任何时刻都有一个状态&#xff0c;该状态表示了MySQL当前正在做什么。SHOW PROCESSLIST 命令的…
阅读更多...
行人实时动作识别

行人实时动作识别

详细资料和代码请加微信&#xff1a;17324069443 一、项目介绍 基于PyTorchVideo的实时动作识别框架&#xff1a; 我们选择了yolov5作为目标检测器&#xff0c;而不是Faster R-CNN&#xff0c;它速度更快、更方便。 我们使用一个跟踪器&#xff08;deepsort&#xff09;来为不…
阅读更多...
STM32CubeIDE基础学习-安装芯片固件支持包

STM32CubeIDE基础学习-安装芯片固件支持包

STM32CubeIDE基础学习-添加芯片固件支持包 前言 前面的文章在安装STM32CubeIDE软件时没有安装这个芯片PACK包&#xff0c;如果工程没有这个固件支持包的话是无法正常使用的&#xff0c;随便安装一个和芯片对应系列的支持包就可以了。 这篇文章来记录一下新增PACK包的常用操作…
阅读更多...
【Docker】Windows11操作系统下安装、使用Docker保姆级教程

【Docker】Windows11操作系统下安装、使用Docker保姆级教程

【Docker】Windows11操作系统下安装、使用Docker保姆级教程 大家好 我是寸铁&#x1f44a; 总结了一篇【Docker】Windows11操作系统下安装、使用Docker保姆级教程的文章✨ 喜欢的小伙伴可以点点关注 &#x1f49d; 前言 什么是 Docker&#xff1f; Docker 是一个开源平台&…
阅读更多...
【优选算法】前缀和

【优选算法】前缀和

前缀和思想其实就是一种简单的dp思想&#xff0c;也就是动态规划 什么时候用到前缀和&#xff1f;当要快速求出数组中某一个区间的和 前缀和模板 暴力解法 定义一个指针从左向右遍历&#xff0c;并且累加值即可&#xff0c;这里就不过多赘述&#xff0c;主要还是来看前缀和…
阅读更多...
缓存雪崩、击穿、穿透

缓存雪崩、击穿、穿透

目录 前言 一、缓存雪崩 1.大量数据同时过期 1.均匀设置过期时间 2.互斥锁 3.后台更新缓存 2.Redis故障宕机 1.服务熔断或请求限流机制 2.构建Redis缓存高可靠集群 二、缓存击穿 1.设置互斥锁&#xff1b; 2.不给热点数据设置过期时间&#xff0c;由后台更新缓存。 …
阅读更多...
可行性研究报告-范例直接套用

可行性研究报告-范例直接套用

1业务需求可行性分析 2技术可行性分析 2.1规范化原则 2.2高度的兼容性和可移植性 2.3人性化、适用性 2.4标准化统一设计原则 2.5先进安全可扩展性原则 3开发周期可行性分析 4人力资源可行性分析 5成本分析 6收益分析 7结论 软件开发多套实际项目案例、方案、源码获取&#xff1…
阅读更多...
使用API有效率地管理Dynadot域名，进行DNS域名解析

使用API有效率地管理Dynadot域名，进行DNS域名解析

关于Dynadot Dynadot是通过ICANN认证的域名注册商&#xff0c;自2002年成立以来&#xff0c;服务于全球108个国家和地区的客户&#xff0c;为数以万计的客户提供简洁&#xff0c;优惠&#xff0c;安全的域名注册以及管理服务。 Dynadot平台操作教程索引&#xff08;包括域名邮…
阅读更多...
nodejs，JSDOM 补 window环境

nodejs，JSDOM 补 window环境

window[atob] 是一个在浏览器中使用的 JavaScript 函数&#xff0c;用于将 base64 编码的字符串解码为原始数据。具体来说&#xff0c;atob 函数会将 base64 字符串解码为一个 DOMString&#xff0c;其中包含解码后的二进制数据。这在处理从服务器获取的 base64 编码的数据或在…
阅读更多...
RedisDesktopManager连接Ubuntu的Redis失败解决办法

RedisDesktopManager连接Ubuntu的Redis失败解决办法

配置redis 1.设置redis在后台服务&#xff0c;修改配置文件 默认情况下是 no ,修改为yes&#xff0c;可以后台服务 2、设置redis端口&#xff0c;默认端口是6379&#xff0c;可以根据自己的需要&#xff0c;找到/et/redis/redis.conf文件, 修改port 3、设置密码 配置文件中…
阅读更多...
基于pytorch的手写体识别

基于pytorch的手写体识别

一、环境搭建 链接: python与深度学习——基础环境搭建 二、数据集准备 本次实验用的是MINIST数据集&#xff0c;利用MINIST数据集进行卷积神经网络的学习&#xff0c;就类似于学习单片机的点灯实验&#xff0c;学习一门机器语言输出hello world。MINIST数据集&#xff0c;可以…
阅读更多...
【书籍推广】这本书太好了！150页就能让你上手大模型应用开发

【书籍推广】这本书太好了！150页就能让你上手大模型应用开发

文章目录 蛇尾书特色蛇尾书思维导图作译者简介业内专家书评 如果问个问题&#xff1a;有哪些产品曾经创造了伟大的奇迹&#xff1f;ChatGPT 应该会当之无愧入选。仅仅发布 5 天&#xff0c;ChatGPT 就吸引了 100 万用户——当然&#xff0c;数据不是关键&#xff0c;关键是其背…
阅读更多...
【Unity】VR开发的正确测试节奏

【Unity】VR开发的正确测试节奏

【背景】 VR开发由于其测试时对设备的依赖较大&#xff0c;因此有时在没有测试条件时想当然地写了大量代码&#xff0c;一旦到正式测试时需要debug&#xff0c;往往无法判断到底是哪个环节的问题&#xff08;代码&#xff0c;环境&#xff0c;等等&#xff09;。相对于PC平台的…
阅读更多...
最新文章

Copyright @ 2022~2023