万字解析设计模式之单例模式

一、概述

1.1简介

单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象

1.2结构

单例模式的主要有以下角色:

  • 单例类。只能创建一个实例的类
  • 访问类。使用单例类

1.3单例模式的实现

单例设计模式分类两种:

饿汉式:类加载就会导致该单实例对象被创建

懒汉式:类加载不会导致该单实例对象被创建,而是首次使用该对象时才会创建

饿汉式-方式1(静态变量方式) 

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}//在成员位置创建该类的对象private static Singleton instance = new Singleton();//对外提供静态方法获取该对象public static Singleton getInstance() {return instance;}
}

这是一个单例模式的实现,确保在程序运行中只有一个该类的实例对象存在。

具体实现:

1. 将类的构造方法私有化,防止外部直接通过构造方法创建对象。

2. 在类的成员位置创建一个私有静态的对象 instance,确保了Singleton类不能在外部被实例化,只能在类内部创建对象。

3. 对外提供一个静态的方法 getInstance(),返回该类的对象 instance,确保在程序中只有一个该类的实例对象存在

4. 由于 instance 是私有的静态成员,在类加载时就已经创建了该对象,所以在 getInstance() 方法中直接返回 instance 即可。由于instance是static成员,类的所有对象共享同一份instance,从而保证了在应用中只有一个Singleton对象被创建。

需要注意的是,该实现方法并未考虑线程安全性,可能会存在线程安全问题

使用单例模式可以避免重复创建对象,节省内存空间,并且可以确保对象在程序中只有一个实例,保证数据一致性。

package com.yanyu.Singleton;public class client{public static void main(String[]args){//创建singletion类的对象Singleton instance = Singleton.getInstance();Singleton instance1 = Singleton.getInstance();//判断获取到的两个是否是同一个对象System.out.println(instance == instance1);}
}

 说明:

该方式在成员位置声明Singleton类型的静态变量,并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话,而一直没有使用就会造成内存的浪费。

饿汉式-方式2(静态代码块方式)

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}//在成员位置创建该类的对象private static Singleton instance;static {instance = new Singleton();}//对外提供静态方法获取该对象public static Singleton getInstance() {return instance;}
}

 这是一种饿汉式单例模式的实现方式,通过静态代码块来初始化单例对象,保证了线程安全性和唯一性。在类被加载时就已经创建了单例对象,因此也叫做饿汉式单例模式。

因为类加载是线程安全的,不需要考虑多线程的情况。

但是,由于对象是在类被加载时就创建的,因此可能会造成资源浪费。如果该单例对象在程序运行期间一直没有被使用,那么一直占据着一部分内存空间,会对系统的性能产生一定的影响。

另外,由于单例对象是静态的,所以对于某些需要动态实现的场景,该实现方式并不合适。

懒汉式-方式1(线程不安全)

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}//在成员位置创建该类的对象private static Singleton instance;//对外提供静态方法获取该对象public static Singleton getInstance() {if(instance == null) {instance = new Singleton();}return instance;}
}

 具体实现是通过私有构造方法来禁止类的外部创建对象,然后在类的成员位置创建该类的唯一对象instance,并通过静态方法getInstance()来返回该对象。在getInstance()方法中,先判断instance是否为null,如果是则创建该对象,否则直接返回该对象。

这种实现方式称为懒汉式单例模式,因为只有在第一次调用getInstance()方法时才会创建对象,而之后的调用都会直接返回已创建的对象。从而避免了多个实例导致的资源浪费和数据不一致等问题。

 懒汉式-方式2(线程安全)

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}//在成员位置创建该类的对象private static Singleton instance;//对外提供静态方法获取该对象public static synchronized Singleton getInstance() {if(instance == null) {instance = new Singleton();}return instance;}
}

 懒汉式相对于饿汉式来说,它是延迟加载的,只有在真正需要使用该对象时才会进行初始化,这样可以节省资源和减少初始化时间。但是,懒汉式实现需要考虑线程安全问题,因为在多线程环境下,如果多个线程同时调用 getInstance() 方法,可能会创建多个实例,导致单例模式失效。因此,需要使用 synchronized 关键字在方法内部进行同步,保证线程安全。

但是在getInstance()方法上添加了synchronized关键字,导致该方法的执行效果特别低

懒汉式-方式3(双重检查锁)

对于 getInstance() 方法来说,绝大部分的操作都是读操作,读操作是线程安全的,所以我们没必让每个线程必须持有锁才能调用该方法,我们需要调整加锁的时机。由此也产生了一种新的实现模式:双重检查锁模式 

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}private static Singleton instance;//对外提供静态方法获取该对象public static Singleton getInstance() {//第一次判断,如果instance不为null,不进入抢锁阶段,直接返回实际if(instance == null) {synchronized (Singleton.class) {//抢到锁之后再次判断是否为空if(instance == null) {instance = new Singleton();}}}return instance;}
}

是怕多线程创建多个对象,如果不为空直接返回提高效率,为空就要加锁防止

首先进行一次非空判断,如果instance为null,才进行同步代码块的抢锁,再次判断instance是否为空,确保只有一个线程可以创建对象。

双重检查锁模式是一种非常好的单例实现模式,解决了单例、性能、线程安全问题,上面的双重检测锁模式看上去完美无缺,其实是存在问题,在多线程的情况下,可能会出现空指针问题,出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

要解决双重检查锁模式带来空指针异常的问题,只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

指令重排序问题解释

在多线程情况下,指令重排序可能会导致该模式的失效。当一个线程抢到锁之后,由于指令重排序的影响,实例变量可能会先被赋值到内存中,但是还没有调用构造函数,而此时另一个线程进入该方法,会认为instance不为空直接返回实例,但是此时实例并没有完成初始化,会导致程序出错。

为了避免这种情况,需要在instance前添加volatile关键字,保证它能正确的被初始化。这样可以确保其他线程在获取instance的时候,总是从主内存中获取,而不是线程的本地内存中获取,从而避免了指令重排序带来的问题。

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}private static volatile Singleton instance;//对外提供静态方法获取该对象public static Singleton getInstance() {//第一次判断,如果instance不为null,不进入抢锁阶段,直接返回实际if(instance == null) {synchronized (Singleton.class) {//抢到锁之后再次判断是否为空if(instance == null) {instance = new Singleton();}}}return instance;}
}

 这是一种线程安全的懒汉式单例模式实现方式,主要特点有:

1. 构造函数私有化,确保该类不能在外部通过构造函数来创建对象。

2. 使用 volatile 关键字修饰 instance,保证在多线程环境下 instance 的可见性。

3. getInstance 方法加入双重检查锁,确保在多线程环境下只有一个线程能够创建 Singleton 实例,并且只有在 instance 为 null 的情况下才会创建实例。

4. 使用 synchronized 关键字对 instance 进行加锁,保证在多线程环境下只有一个线程能够进入创建实例的代码块。

5. 返回 Singleton 实例的方法为静态方法,能够在类的外部方便地获取该对象。

这种实现方式既保证了线程安全,又减少了同步的开销,是一种比较常用的单例模式实现方式。

懒汉式-方式4(静态内部类方式)

静态内部类单例模式中实例由内部类创建,由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰,保证只被实例化一次,并且严格保证实例化顺序。

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}//对外提供静态方法获取该对象public static Singleton getInstance() {return SingletonHolder.INSTANCE;}
}

这是一种利用静态内部类实现的线程安全的单例模式。在类加载器加载类的时候,静态内部类 SingletonHolder 不会被初始化,只有在 getInstance() 方法第一次被调用时,才会被加载进内存并实例化,同时保证了线程安全。这种方式既保证了线程安全,也避免了同步带来的性能损失,同时也实现了延迟加载。由于这种方式不需要加锁,因此效率比较高

 这种方式的核心思想是使用静态内部类来持有单例实例,因为静态内部类只会被加载一次,所以它的成员变量也只会被初始化一次,从而保证了线程安全。同时,通过将单例对象的实例化延迟到内部类加载时进行,也实现了懒加载。

 枚举方式

枚举类实现单例模式是极力推荐的单例实现模式,因为枚举类型是线程安全的,并且只会装载一次,设计者充分的利用了枚举的这个特性来实现单例模式,枚举的写法非常简单,而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

package com.yanyu.Singleton;public enum Singleton {INSTANCE;
}

 INSTANCE是一个枚举对象,也就是该单例类的唯一实例。通过这种方式获取单例对象,可以保证在任何情况下都只有一个实例对象存在。即使在多线程的情况下也是安全的。可以避免多线程问题和反射攻击

package com.yanyu.Singleton;public class client{public static void main(String[]args){//创建singletion类的对象Singleton instance = Singleton.INSTANCE;Singleton instance1 = Singleton.INSTANCE;//判断获取到的两个是否是同一个对象System.out.println(instance == instance1);}
}

在使用枚举类型实现单例模式时,反射攻击是无效的,因为枚举类型的构造方法是私有的,并且只会在类加载时被调用一次,保证了单例的唯一性。在使用反射获取该单例时,会抛出异常,因为枚举类型不支持反射创建实例。因此,枚举类型实现单例模式是一种安全可靠的方式。

1.4破坏单例模式的方式 

使上面定义的单例类(Singleton)可以创建多个对象,枚举方式除外。有两种方式,分别是序列化和反射。

序列化反序列化

Singleton类:

package com.yanyu.Singleton;import java.io.Serializable;public class Singleton implements Serializable {//私有构造方法private Singleton() {}private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}//对外提供静态方法获取该对象public static Singleton getInstance() {return SingletonHolder.INSTANCE;}
}

Test类:

package com.yanyu.Singleton;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;public class Test {public static void main(String[] args) throws Exception {//往文件中写对象//writeObject2File();//从文件中读取对象Singleton s1 = readObjectFromFile();Singleton s2 = readObjectFromFile();//判断两个反序列化后的对象是否是同一个对象System.out.println(s1 == s2);}private static Singleton readObjectFromFile() throws Exception {//创建对象输入流对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt"));//第一个读取Singleton对象Singleton instance = (Singleton) ois.readObject();return instance;}public static void writeObject2File() throws Exception {//获取Singleton类的对象Singleton instance = Singleton.getInstance();//创建对象输出流ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt"));//将instance对象写出到文件中oos.writeObject(instance);}
}

上面代码运行结果是false,表明序列化和反序列化已经破坏了单例设计模式。

当单例模式中的实例被序列化成字节流并保存到文件系统或数据库中时,如果后续读取对象并反序列化后,会生成一个新的实例,从而破坏了单例模式的原则。

这是因为,在序列化和反序列化过程中,Java内部使用了一个特殊的方法来创建对象,该方法不会调用任何构造函数,也不会检查是否已经存在该对象的实例。因此,如果单例模式本身没有实现序列化和反序列化的特殊处理,就会导致破坏单例模式。

 序列化会将对象转换为一个字节序列,以便在网络上传输或保存到文件中。当反序列化时,会将字节序列转换回对象。当单例类被序列化为字节流时,字节流中不包含单例类的状态,当反序列化时,新的实例会被创建出来,这样就违反了单例模式的原则,一个单例类就被破坏了。

反射 

Singleton类:

package com.yanyu.Singleton;public class Singleton {//私有构造方法private Singleton() {}private static volatile Singleton instance;//对外提供静态方法获取该对象public static Singleton getInstance() {if(instance != null) {return instance;}synchronized (Singleton.class) {if(instance != null) {return instance;}instance = new Singleton();return instance;}}
}

Test类:

package com.yanyu.Singleton;import java.lang.reflect.Constructor;public class Test {public static void main(String[] args) throws Exception {//获取Singleton类的字节码对象Class clazz = Singleton.class;//获取Singleton类的私有无参构造方法对象Constructor constructor = clazz.getDeclaredConstructor();//取消访问检查constructor.setAccessible(true);//创建Singleton类的对象s1Singleton s1 = (Singleton) constructor.newInstance();//创建Singleton类的对象s2Singleton s2 = (Singleton) constructor.newInstance();//判断通过反射创建的两个Singleton对象是否是同一个对象System.out.println(s1 == s2);}
}

上面代码运行结果是false,表明反射已经破坏了单例设计模式

 单例模式可以被反射机制破坏,因为反射机制可以通过修改类的私有构造方法来创建一个新的实例,这样就违背了单例模式的原则。此外,反射还可以通过修改单例类中的字段来改变单例实例的状态,从而破坏单例模式的行为。

1.5 问题的解决

序列化、反序列方式解决

在Singleton类中添加readResolve()方法,在反序列化时被反射调用,如果定义了这个方法,就返回这个方法的值,如果没有定义,则返回新new出来的对象。

Singleton类:

package com.yanyu.Singleton;import java.io.Serializable;public class Singleton implements Serializable {//私有构造方法private Singleton() {}private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}//对外提供静态方法获取该对象public static Singleton getInstance() {return SingletonHolder.INSTANCE;}/*** //当,进行反序列化时,会白动调用该力法,将该方法的返回值直接返回*/private Object readResolve() {return SingletonHolder.INSTANCE;}
}

当反序列化时,会先调用 readObject() 方法,如果该类中存在 readResolve() 方法,会在 readObject() 方法执行之后,将 readResolve() 方法的返回值直接返回,从而确保只有一个实例。在该示例中,readResolve() 方法返回 SingletonHolder 的 INSTANCE,即单例对象的唯一实例。

反射方式解决

为了防止这种破解,可以在单例类的构造函数中添加判断,如果已存在实例,则抛出异常或返回已存在的实例。这样,在通过反射调用私有构造函数时,就会抛出异常或返回已存在的实例,从而阻止破解单例模式。

package com.yanyu.Singleton;public class Singleton {private static boolean flag = false;//私有构造方法private Singleton() {/*反射破解单例模式需要添加的代码*/synchronized (Singleton.class){if (flag){throw new RuntimeException("不能创建多个对象");}flag = true;}}private static volatile Singleton instance;//对外提供静态方法获取该对象public static Singleton getInstance() {if(instance != null) {return instance;}synchronized (Singleton.class) {if(instance != null) {return instance;}instance = new Singleton();return instance;}}
}

上述代码中的防止反射破解的代码可以阻止通过反射调用私有构造方法创建多个实例。但是,如果通过反射修改了flag标志位,就可以绕过这个限制,破坏单例模式。

为了进一步防止通过反射破解单例模式,可以在getInstance方法中添加判断,如果已存在实例,再次调用构造方法时,直接返回已存在的实例。这样,即使通过反射修改了flag标志位,也无法创建新的实例,从而保证单例模式的唯一性。

 1.6JDK源码解析-Runtime类

 从上面源代码中可以看出Runtime类使用的是恶汉式(静态属性)方式来实现单例模式的。

使用Runtime类中的方法


public class RuntimeDemo {public static void main(String[] args) throws IOException {//获取Runtime类对象Runtime runtime = Runtime.getRuntime();
​//返回 Java 虚拟机中的内存总量。System.out.println(runtime.totalMemory());//返回 Java 虚拟机试图使用的最大内存量。System.out.println(runtime.maxMemory());
​//创建一个新的进程执行指定的字符串命令,返回进程对象Process process = runtime.exec("ipconfig");//获取命令执行后的结果,通过输入流获取InputStream inputStream = process.getInputStream();byte[] arr = new byte[1024 * 1024* 100];int b = inputStream.read(arr);System.out.println(new String(arr,0,b,"gbk"));}
}

1.7应用案例

  • Windows 的 Task Manager(任务管理器)。
  • Windows 的 Recycle Bin(回收站)。在整个系统运行过程中,回收站一直维护着仅有的一个实例。
  • 网站的计数器,一般也是采用单例模式实现,否则难以同步。
  • 应用程序的日志应用,一般都何用单例模式实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加。
  • Web 应用的配置对象的读取,一般也应用单例模式,这个是由于配置文件是共享的资源。

二、实验

任务描述

在企业网站后台系统中,一般会将网站统计单元进行独立设计,比如登录人数的统计、IP 数量的计数等。在这类需要完成全局统计的过程中,就会用到单例模式,即整个系统只需要拥有一个计数的全局对象。

本关任务:模拟网站登录,高并发场景。模拟 10 个登录线程,程序输出登录总数。

实现要点

  1. 在类中添加一个私有静态成员变量用于保存单例实例。
  2. 声明一个公有静态构建方法用于获取单例实例。
  3. 在静态方法中实现"延迟初始化"。 该方法会在首次被调用时创建一个新对象, 并将其存储在静态成员变量中。 此后该方法每次被调用时都返回该实例。
  4. 将类的构造函数设为私有。 类的静态方法仍能调用构造函数, 但是其他对象不能调用。
  5. 检查客户端代码, 将对单例的构造函数的调用替换为对其静态构建方法的调用。

编程要求

本任务有三个文件“Login.java”、“Client.java”和“Singleton.java”,在右侧编辑器 Begin-End 内补充 Singleton 中代码,其它文件请阅读代码

Singleton.java 

package step1;import java.util.concurrent.atomic.AtomicLong;public class Singleton {private static Singleton instance;//AtomicLong是以原子方式操作long值的类,作用是保证并发时线程安全的累加private AtomicLong count = new AtomicLong(0);/********** Begin *********///此处增加Singleton的构造函数private Singleton() {// 私有化构造函数,防止外部实例化}/********** End *********/public static Singleton GetInstance(){/********** Begin *********///考虑线程安全问题if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;/********** End *********/}public AtomicLong getCount() {return count;}public void setCount() {count.addAndGet(1);}
}

 Login.java

package step1;
//Runnable 接口由其实现类来由线程执行对应的实例。对于实现类必须是实现方法 run
public class Login implements Runnable{private String loginname;public String getLoginname() {return loginname;}public void setLoginname(String loginname) {this.loginname = loginname;}@Overridepublic void run() {Singleton lazySingleton =Singleton.GetInstance();lazySingleton.setCount();/*调试时观察System.out.println(getLoginname()+"登录成功."+lazySingleton);*/}
}

Client.java

package step1;public class Client {public final static int num = 10;public static void main(String[] args) throws InterruptedException {///创建10个线程,模拟10个用户登录Thread[] threads = new Thread[num];for (int i = 0; i < num; i++) {Login login = new Login();login.setLoginname("" + String.format("%2s", (i + 1)) + "号用户");//创建了线程threads[i],并把login对象(已实现Runnable接口)放入线程中threads[i]=new Thread(login);//线程状态转换为RUNNABLEthreads[i].start();}for (Thread thread : threads) {//Client等待线程结束之后才能继续运行,防止最后一行的System.out.println提前运行thread.join();}System.out.println("网站共有"+Singleton.GetInstance().getCount()+"个用户登录");}
}

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

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

相关文章

分享个包含各省、市、区的编码数据的在线静态资源脚本

在翻《SpringBootVue3》——十三尼克陈作者的大型前后端分离项目实战里面&#xff0c;在看到地址管理的部分时&#xff0c;发现了该作者记录有一个静态的地址资源脚本 这里做个记录&#xff0c;打点 一、引入js <script src"https://s.yezgea02.com/1641120061385/td…

IT行业变成了夕阳行业

IT技术发展背景及历程 从2010年左右开始&#xff0c;大众创新&#xff0c;万众创业变成了一个经常看到的词语&#xff0c;在创业潮的带动下&#xff0c;同时刚好赶上了互联网的高速发展&#xff0c;一大批互联网创业公司应运而生&#xff0c;在这样的背景下&#xff0c;IT行业…

轻量级 SSO 方略

单点登录 SSO&#xff08;Single Sign On&#xff09;是在多个应用系统中&#xff0c;用户只需要登录一次就可以访问所有相互信任的应用系统。打通所有系统的账户密码&#xff0c;只需要记住一个就行&#xff0c;而且登录一个系统后&#xff0c;打开其他系统不需要再登录。广义…

C# 递归算法使用简介_常用整理

一、递归简介 递归算法是一种直接或者间接调用自身函数或者方法的算法。 递归算法的实质是把问题分解成规模缩小的同类问题的子问题&#xff0c;然后递归调用方法来表示问题的解。递归算法对解决一大类问题很有效&#xff0c;它可以使算法简洁和易于理解。 递归本质是循环&a…

【linux】SourceForge 开源软件开发平台和仓库

在linux上面安装服务和工具。我们经常会下载安装包。今天推荐一个网站。 SourceForge 开源软件开发平台和仓库 ​ 全球最大开源软件开发平台和仓库 SourceForge.net&#xff0c;又称SF.net&#xff0c;是开源软件开发者进行开发管理的集中式场所。 SourceForge.net由VA Softwa…

如何使用ffmpeg制作透明背景的视频

最近我们尝试在网页上叠加数字人讲解的功能&#xff0c;发现如果直接在网页上放一个矩形的数字人视频&#xff0c;效果会很差&#xff0c;首先是会遮挡很多画面的内容&#xff0c;其次就是不管使用任何任务背景&#xff0c;画面都和后面的网页不是很协调&#xff0c;如图所示&a…

Flutter笔记:完全基于Flutter绘图技术绘制一个精美的Dash图标(下)

Flutter笔记 完全基于Flutter绘图技术绘制一个精美的Dart吉祥物Dash 作者&#xff1a;李俊才 &#xff08;jcLee95&#xff09;&#xff1a;https://blog.csdn.net/qq_28550263 邮箱 &#xff1a;291148484163.com 本文地址&#xff1a;https://blog.csdn.net/qq_28550263/arti…

【JavaEE】HTTP协议

HTTP协议 HTTP是什么?HTTP 协议格式HTTP 请求格式HTTP响应格式协议格式总结 HTTP 请求 (Request)认识 URLURL 基本格式 关于 URL encode认识 "方法" (method)1. GET 方法2. POST 方法 认识请求 "报头" (header) HTTP 响应详解认识 "状态码" (st…

Azure - 机器学习:创建机器学习所需资源,配置工作区

目录 一、Azure机器学习工作区与计算实例简要介绍工作区计算实例 二、创建工作区1. 登录到 Azure 机器学习工作室2. 选择“创建工作区”3. 提供以下信息来配置新工作区&#xff1a;4. 选择“创建”以创建工作区 三、创建计算实例四、工作室实战4.1 工作室快速导览4.2 从示例笔记…

「Java开发指南」如何在MyEclipse中使用JPA和Spring管理事务?(二)

本教程中介绍一些基于JPA/ spring的特性&#xff0c;重点介绍JPA-Spring集成以及如何利用这些功能。您将学习如何&#xff1a; 为JPA和Spring设置一个项目逆向工程数据库表来生成实体实现创建、检索、编辑和删除功能启用容器管理的事务 在上文中&#xff08;点击这里回顾>…

Flink将数据写入MySQL(JDBC)

一、写在前面 在实际的生产环境中&#xff0c;我们经常会把Flink处理的数据写入MySQL、Doris等数据库中&#xff0c;下面以MySQL为例&#xff0c;使用JDBC的方式将Flink的数据实时数据写入MySQL。 二、代码示例 2.1 版本说明 <flink.version>1.14.6</flink.version…

DBSCAN算法c++实现

首先计算出距离每个点e以内的点&#xff0c;如果个数>minPts,则找出它的直接密度可达和间接可达的点&#xff0c;用visited标记点是否已经在簇中&#xff0c;循环直到最后一个点。 #include <fstream> #include <vector> #include <iostream> #include &…

广州华锐互动:VR技术应用到工程项目施工安全培训的好处

随着科技的飞速发展&#xff0c;虚拟现实(VR)技术已经深入到各个领域。在建筑施工领域&#xff0c;VR技术的应用为工程项目施工安全培训带来了许多好处。本文将探讨VR技术在这方面的优势和应用。 首先&#xff0c;VR技术能够提供沉浸式的安全培训体验。通过VR设备&#xff0c;学…

x210项目重新回顾之十七升级到linux4.19.114 +buildroot2018再讨论

代码参考https://github.com/colourfate/x210_bsp/ 他的是linux_4.10(dtb为 s5pv210-x210..dtb)我打算用linux4.19.114(dtb为 s5pv210-smdkv210.dtb) &#xff0c;所以修改build.sh ------------------------------------------------------------------------------ 5 M…

【开源】基于SpringBoot的高校学院网站的设计和实现

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 学院院系模块2.2 竞赛报名模块2.3 教育教学模块2.4 招生就业模块2.5 实时信息模块 三、系统设计3.1 用例设计3.2 数据库设计3.2.1 学院院系表3.2.2 竞赛报名表3.2.3 教育教学表3.2.4 招生就业表3.2.5 实时信息表 四、系…

python之计算平面点集的的面积

在当今数据驱动的世界中&#xff0c;计算平面点集的最小外接轮廓面积被广泛应用于各种实际场景中。它是一项重要而魅力十足的任务&#xff0c;旨在找到一个最小的矩形或多边形区域&#xff0c;能够完全包围给定的离散点集。这个看似简单的问题背后隐藏着许多挑战&#xff0c;需…

python爬虫之feapder.AirSpider轻量爬虫案例:豆瓣

创建feaderSpider项目&#xff1a;feapder create -p feapderSpider&#xff0c;已创建可忽略进入feapderSpider目录&#xff1a;cd .\ feapderSpider\spiders创建爬虫&#xff1a;feapder create -s airSpiderDouban&#xff0c;选择AirSpider爬虫模板&#xff0c;可跳过1、2直…

KMS在腾讯云的微服务实践助力其降本50%

背景介绍 KMS 是一家日本的游戏公司&#xff0c;主要经营游戏业务、数字漫画业务、广告业务、云解决方案业务等&#xff0c;出品了多款在日本畅销的漫画风游戏&#xff0c;同时有网络漫画专业厂牌&#xff0c;以内容创作为目标&#xff0c;拥有原创 IP 创作、游戏开发等多元化发…

bitlocker 加密锁定的固态硬盘,更换到别的电脑上,怎么把原密钥写进新电脑TPM芯片内,开启无需手动填密钥

环境: Win11 专业版 联想E14笔记本 512G ssd 问题描述: 一台笔记本因充电故障,需要拿去维修,不想重装系统,将bitlocker 加密锁定的固态硬盘拆下更换到别的笔记本电脑上,现在开机要手动填密钥,怎么把原密钥写进新电脑TPM芯片内,开启无需手动填密钥和之前那台电脑一…

DevOps与CI/CD的最佳实践

在当今的软件开发领域&#xff0c;DevOps&#xff08;开发与运维的结合&#xff09;和CI/CD&#xff08;持续集成/持续交付&#xff09;已经成为了不可或缺的一部分。它们不仅提高了软件开发的效率&#xff0c;还帮助团队更快地交付高质量的软件。本文将深入探讨DevOps文化和CI…