RAII - 安卓中的智能指针

RAII - 安卓中的智能指针

概念 sp wp RefBase

是什么
system/core/libutils/RefBase.cpp
system/core/libutils/include/utils/RefBase.hsystem/core/libutils/StrongPointer.cpp
system/core/libutils/include/utils/StrongPointer.h

Android在标准库之外，自定义了以下两种智能指针类型：

  • 强指针sp（strong pointer），弱指针 wp（weak pointer）都是模板类

  • sp 和share_ptr概念相同。wp 和weak_ptr概念相同。sp和wp has-a RefBase

    • 弱指针仅仅记录对象的地址，不能通过弱指针来访问该对象。要想访问弱指针所指向的对象，需首先通过wp类所提供的promote()方法将弱指针升级为强指针。

    • 弱指针所指向的对象是有可能在其它地方被销毁的。如果对象已经被销毁，wp的promote()方法将返回空指针，这样就能避免出现地址访问错的情况。

支持使用 sp 和 wp的对象，必须继承RefBase类。观察Android 中使用sp 和 wp的地方，传进来的模板参数都是继承自RefBase，例如：

// MediaPlayer是支持使用强指针和弱指针的对象
class MediaPlayer : public BnMediaPlayerClient,public virtual IMediaDeathNotifier
{
public:MediaPlayer();~MediaPlayer();
// 父类是 BnMediaPlayerClient 和 IMediaDeathNotifier，
// 多继承可能出现菱形继承，因此 虚继承自 RefBase
class IMediaDeathNotifier: virtual public RefBase
{
public:IMediaDeathNotifier() { addObitRecipient(this); }virtual ~IMediaDeathNotifier() { removeObitRecipient(this); }//随便找个，可以看到是继承RefBase，注意的是虚拟继承。
怎么用
// 使用智能指针的类必须继承自 RefBase
class Ressource : public RefBase { Ressource(int){}void test() {}
}{ // 作用域开始// 强引用 sp 构造函数有很多，这里简单列举两个Ressource* p = new Ressource(1);sp<Ressource> sp1(p);  // 1sp<Ressource> sp1 = new Ressource(1); // 2// sp::make 提供内存连贯性&缓存命中: 构建一个 sp 对象，其内部new一个资源对象，在将成员变量 m_ptr 指针指向它 static sp<Ressource> sp1 = sp<Ressource>::make(1); // 3// 通过强引用，操作指针指向的对象sp1->test();// 不能直接通过弱引用使用对象，升级为强指针再使用wp<Ressource> wp1(p); // 弱引用sp<Ressource> sp2 = wp1.promote();if(sp2 != NULL) {  // sp重载了 != 原本spRessource2与 NULL 不是同一类型sp2->test();}
}   // 作用域结束，调用强引用对象的析构函数，释放掉 p 指针指向的内存
对比标准库
为什么不直接用标准库？

为什么不用标准库？

1、历史原因！C++11推出 shared_ptr 和 weak_ptr之前，Android就已经需要存在了。

2、特殊的功能：有些功能是针对特定使用场景定制的（显然不符合 C++ 标准）。

例如，特殊的接口：

template<typename T>
class sp {//! Special optimization for use by ProcessState (and nobody else).void force_set(T* other);
}
template<typename T>
void sp<T>::force_set(T* other) {other->forceIncStrong(this);m_ptr = other;
}

例如，智能指针有两种模式

  • 强引用控制 OBJECT_LIFETIME_STRONG （默认，且绝大多数情况下都是强引用控制）
  • 弱引用控制 OBJECT_LIFETIME_WEAK

可通过 void RefBase::extendObjectLifetime(int32_t mode) 函数切换。强/弱引用控制的切换，通常在被管理的目标类的构造函数中调用：

// system/core/libutils/include/utils/RefBase.h
enum {OBJECT_LIFETIME_STRONG  = 0x0000, //强引用控制OBJECT_LIFETIME_WEAK    = 0x0001, //弱引用控制// 掩码值，可使用 flag&OBJECT_LIFETIME_MASK 的形式来获取 flag 的最低位数值OBJECT_LIFETIME_MASK    = 0x0001
};// frameworks/native/libs/binder/BpBinder.cpp
BpBinder::BpBinder(Handle&& handle) {// 调用函数修改智能指针模式extendObjectLifetime(OBJECT_LIFETIME_WEAK);
}

例如，神奇的功能：

static void check_not_on_stack(const void* ptr) {
实现上的区别

从被管理的资源的角度来看：

标准库的 shared_ptr，”管理它所持有的 裸指针“。

  • 被管理的资源——裸指针所指向的对象，可以是任意类型。
  • 处于"被管理状态"，不会对资源本身造成什么影响，没有负担。

Android 实现的 sp，wp ”操作它所持有的 RefBase类的计数“。

  • 被管理的资源——必须是 RefBase类，即被管理要求原有类型必须继承 RefBase类。
  • 处于"被管理状态"，意味着
    • 资源类RefBase 自身保存计数，保存的强引用计数归零后自己执行delete this
    • sp wp 会去操作，让资源类去管理自身保存的计数
优缺点

Android这样不使用 STD 智能指针的做法，

优点：总结来说就是，客制化的美~

  1. 允许进行根据需求自定义的修改/优化。

    前文介绍过的，特殊接口，强/弱引用控制

  2. 安卓fwk中普遍存在跨进程“引用资源”的的情况，RefBase 自行计数方便IPC情境下的管理。

  3. 方便且臃肿的 debug 函数

缺点：总结来说就是，增大对象本身的开销

  1. 对象占用内存增高—— 作为操作系统必要，但是其它场景不需要的开销

    诸如函数RefBase::getStrongCount()，RefBase::weakref_type::trackMe()

  2. 资源类有时候需要虚继承 RefBase —— 为了解决菱形继承而不可避免的选择。因此相较于使用标准库的智能指针，每次更改计数都不得不承担虚函数表带来的开销。

  3. 不同于标准库这件事情本身就会影响可读性，引入新的复杂度。

你自己看看复杂不复杂，臃肿不臃肿

void RefBase::weakref_type::decWeak(const void* id)
{weakref_impl* const impl = static_cast<weakref_impl*>(this);impl->removeWeakRef(id); //删除弱引用//减少对象的弱引用计数，并且返回减少之前的值，存储在c中const int32_t c = impl->mWeak.fetch_sub(1, std::memory_order_release); //计数减1ALOG_ASSERT(c >= 1, "decWeak called on %p too many times", this);/*如果c不等于1则不用进行处理，如果c=1，说明弱引用计数为0，则强引用计数必定也为0，则考虑如何释放该对象*/if (c != 1) return; //还有其他引用在用这个指针，直接返回/*释放方式取决于当前对象的生命周期控制标志mFlags的值0，只要强引用计数为0，系统则自动释放这个对象OBJECT_LIFETIME_WEAK，只有强引用计数和弱引用计数都为0，系统才会自动释放这个对象OBJECT_LIFETIME_FOREVER，系统永远不会释放这个对象，需要开发者手动释放*/   atomic_thread_fence(std::memory_order_acquire);// ...

RefBase类

首先，这屌东西里面有什么。它能干啥？

类方法
内部类
类方法
derived
成员变量
has-a
has-a
RefBase
incStrong/decStrong/createWeak
weakref_type
incWeak/decWeak
weakref_impl
weakref_type* mRefs 描述对象的引用计数
sp
m_ptr, RefBase*
wp
m_refs, weakref_type*
内部类 weakref_type

RefBase类 有两个内部类：定义 & 实现 引用计数维护接口

  • class weakref_type：定义接口
  • class weakref_impl：具体实现（weakref_type继承weakref_impl）

成员变量RefBase::mRefs，类型就是刚刚提到的内部类 weakref_impl* const——描述对象的引用计数。

内部类weakref_type 提供有类方法：

  • 增加/减少 弱引用计数：weakref_type::incWeak，weakref_type::decWeak
  • 维护对象的强/弱引用计数：weakref_type::attemptIncStrong，weakref_type::attemptIncWeak
class RefBase {friend class weakref_type;class weakref_type {/*...*/};class weakref_impl;//使用一个weakref_impl对象来描述对象的引用计数weakref_impl* const mRefs;
class RefBase::weakref_impl : public RefBase::weakref_type
成员函数

RefBase类 有一系列 成员函数

  • 关于强引用：incStrong，incStrongRequireStrong，decStrong，forceIncStrong

  • 关于弱引用：createWeak，getWeakRefs，

createWeak类方法，返回weakref_type类型的指针。

sp wp

sp

  • sp::m_ptr 的类型是 T* 即 RefBase * ——sp has-a RefBase

  • 控制计数，最终调用：RefBase::incStrong 和RefBase::decStrong方法

template <typename T>
class sp {// T 类型就是 RefBase 的子类T* m_ptr;
};
// decStrong 和incStrong的具体实现，在RefBase类中。
void RefBase::incStrong(const void* id) const
void RefBase::decStrong(const void* id) const

wp

  • wp::m_refs的类型是RefBase::weakref_type *
  • 控制计数，最终调用：RefBase::incStrong 和RefBase::decStrong方法
// RefBase::weakref_type中实现
RefBase::weakref_type* RefBase::createWeak(const void* id) const
void RefBase::weakref_type::incWeak(const void* id)
void RefBase::weakref_type::decWeak(const void* id)
强引用 sp

通过 初始化/传入参数 设置m_ptr，m_ptr必须是RefBase类的派生类（虚继承），从而使用 RefBase::incStrong和RefBase::decStrong修改RefBase本身的引用计数。

sp构造时：初始化sp中RefBase类型的指针 m_ptr，并调用指针incStrong()进行计数加1

sp析构时：指针T *m_ptr需要将计数减1

template<typename T>
sp<T>::sp(T* other): m_ptr(other) {if (other)other->incStrong(this);
}template<typename T>
sp<T>::~sp()
{if (m_ptr) m_ptr->decStrong(this);
}
弱引用 wp

成员变量 wp::m_ptr ，wp::m_refs

  • wp::m_ptr 类型是RefBase类型的指针，指向资源RefBase本身。
  • wp::m_refs 类型是RefBase::weakref_type，即资源RefBase的成员变量RefBase::mRefs——用于指向管理资源的内部类。

构造/移动&拷贝/赋值/清空时，以上两个成员变量被同时修改。

通过成员变量wp::m_refs（类型为RefBase::weakref_type）的成员函数去修改资源RefBase计数。

template <typename T>
class wp
{typedef typename RefBase::weakref_type weakref_type;T*              m_ptr;weakref_type*   m_refs;
};template<typename T>
wp<T>::~wp()
{if (m_ptr) m_refs->decWeak(this);
}

源码注释 RefBase

接口
class RefBase
{
public://增加强引用计数void            incStrong(const void* id) const;//减少强引用计数void            decStrong(const void* id) const;// (wp中的m_refs调用)weakref_type*   createWeak(const void* id) const;weakref_type*   getWeakRefs() const;void            forceIncStrong(const void* id) const;int32_t         getStrongCount() const;// 定义了内部类：weakref_type weakref_implclass weakref_type{public:RefBase*            refBase() const;//增加弱引用计数 (wp中的m_refs调用)void                incWeak(const void* id);//减少弱引用计数 (wp中的m_refs调用)void                decWeak(const void* id);//维护对象的强引用计数bool                attemptIncStrong(const void* id);//维护对象的弱引用计数bool                attemptIncWeak(const void* id);// debug用函数int32_t             getWeakCount() const;void                printRefs() const;void                trackMe(bool enable, bool retain);};// Debug 函数...// 允许自定义的Destroyerclass Destroyer {friend class RefBase;public:virtual ~Destroyer();private:virtual void destroy(RefBase const* base) = 0;};void setDestroyer(Destroyer* destroyer);
protected:RefBase();virtual ~RefBase();// 生命周期有关的flag，函数...// 一堆其它功能的虚函数...
private:friend class weakref_type;class weakref_impl;RefBase(const RefBase& o);RefBase& operator=(const RefBase& o);//使用一个weakref_impl对象来描述对象的引用计数weakref_impl* const mRefs;
};
强引用
decStrong

RefBase类的成员函数decStrong减少对象的引用计数

实现如下：

void RefBase::decStrong(const void* id) const
{weakref_impl* const refs = mRefs;refs->removeStrongRef(id);//移除强引用链表中的引用idconst int32_t c = refs->mStrong.fetch_sub(1, std::memory_order_release);//计数减1
#if PRINT_REFSALOGD("decStrong of %p from %p: cnt=%d\n", this, id, c);
#endifALOG_ASSERT(c >= 1, "decStrong() called on %p too many times", refs);if (c == 1) {//如果是最后一个了，那需要释放该指针了std::atomic_thread_fence(std::memory_order_acquire);refs->mBase->onLastStrongRef(id);int32_t flags = refs->mFlags.load(std::memory_order_relaxed);if ((flags&OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {delete this;}}refs->decWeak(id);//如果不是最后一个，需要减少弱引用链表
}
incStrong

RefBase类的成员函数incStrong 增加对象的引用计数

实现如下：

frameworks/base/libs/utils/RefBase.cpp
//RefBase类的成员函数incStrong来增加对象的引用计数
void RefBase::incStrong(const void* id) const
{weakref_impl* const refs = mRefs;refs->addWeakRef(id);refs->incWeak(id);//增加对象的引用计数refs->addStrongRef(id);//增加对象的强引用计数const int32_t c = android_atomic_inc(&refs->mStrong);LOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);#if PRINT_REFSLOGD("incStrong of %p from %p: cnt=%d\n", this, id, c);
#endifif (c != INITIAL_STRONG_VALUE)  {return;}android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);
//如果对象第一次被强指针引用，进行通知const_cast<RefBase*>(this)->onFirstRef()
}
弱引用
incWeak

只有RefBase::weakref_type的对象才能调用 incWeak和decWeak。

frameworks/base/libs/utils/RefBase.cpp
void RefBase::weakref_type::incWeak(const void* id)
{weakref_impl* const impl = static_cast<weakref_impl*>(this);impl->addWeakRef(id);const int32_t c = android_atomic_inc(&impl->mWeak);LOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);
}
decWeak

只有RefBase::weakref_type的对象才能调用 incWeak和decWeak。

void RefBase::weakref_type::decWeak(const void* id)
{weakref_impl* const impl = static_cast<weakref_impl*>(this);impl->removeWeakRef(id); //删除弱引用//减少对象的弱引用计数，并且返回减少之前的值，存储在c中const int32_t c = impl->mWeak.fetch_sub(1, std::memory_order_release); //计数减1ALOG_ASSERT(c >= 1, "decWeak called on %p too many times", this);/*如果c不等于1则不用进行处理，如果c=1，说明弱引用计数为0，则强引用计数必定也为0，则考虑如何释放该对象*/if (c != 1) return; //还有其他引用在用这个指针，直接返回/*释放方式取决于当前对象的生命周期控制标志mFlags的值0，只要强引用计数为0，系统则自动释放这个对象OBJECT_LIFETIME_WEAK，只有强引用计数和弱引用计数都为0，系统才会自动释放这个对象OBJECT_LIFETIME_FOREVER，系统永远不会释放这个对象，需要开发者手动释放*/   atomic_thread_fence(std::memory_order_acquire);int32_t flags = impl->mFlags.load(std::memory_order_relaxed);if ((flags&OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {// This is the regular lifetime case. The object is destroyed// when the last strong reference goes away. Since weakref_impl// outlive the object, it is not destroyed in the dtor, and// we'll have to do it here.if (impl->mStrong.load(std::memory_order_relaxed)== INITIAL_STRONG_VALUE) {// Special case: we never had a strong reference, so we need to// destroy the object now.delete impl->mBase; //如果没有其他的引用了，需要释放当前指针} else {// ALOGV("Freeing refs %p of old RefBase %p\n", this, impl->mBase);delete impl;}} else {// This is the OBJECT_LIFETIME_WEAK case. The last weak-reference// is gone, we can destroy the object.impl->mBase->onLastWeakRef(id);if ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) {if (impl->mBase) {if (impl->mDestroyer) {impl->mDestroyer->destroy(impl->mBase);} else {delete impl->mBase;//如果没有其他引用了，就释放当前指针}}}}
}
weakref_type 具体实现

weakref_type类定义了引用计数维护接口，具体的实现由weakref_impl类实现。

frameworks/base/libs/utils/RefBase.cpp
class RefBase::weakref_impl : public RefBase::weakref_type
{
public:volatile int32_t    mStrong; 	//描述强引用计数volatile int32_t    mWeak;		//描述弱引用计数RefBase* const      mBase;		//指向它所引用的对象的地址/*mFlags取值范围0，表示对象的生命周期只收强引用计数影响OBJECT_LIFETIME_WEAK，	表示对象的生命周期同时受强引用计数和弱引用计数影响OBJECT_LIFETIME_FOREVER，表示对象的生命周期完全不受强引用指针和弱引用指针影响*/volatile int32_t    mFlags;//描述对象生命周期控制方式Destroyer*          mDestroyer;#if !DEBUG_REFSweakref_impl(RefBase* base): mStrong(INITIAL_STRONG_VALUE), mWeak(0), mBase(base), mFlags(0), mDestroyer(0){}void addStrongRef(const void* /*id*/) { }void removeStrongRef(const void* /*id*/) { }void addWeakRef(const void* /*id*/) { }void removeWeakRef(const void* /*id*/) { }void printRefs() const { }void trackMe(bool, bool) { }#else
....//省略部分不重要内容
#endif
};
析构函数

RefBase类中成员变量mRefs的解析函数的实现。

frameworks/base/libs/utils/RefBase.cpp
RefBase::~RefBase()
{/*如果发现对象的弱引用计数为0，则在释放RefBase对象的同时也将引用计数对象mRefs一起释放掉。mRefs对象在RefBase的构造函数中被创建，指向weakref_impl，如果RefBase对象都不存在了，并且mWeak也为0，mRefs也没有什么存在的必要了。强引用计数一定是小于弱引用计数的，所以强引用计数为0时弱引用计数仍有可能大于0。所以在弱引用计数大于0的情况下我们只释放RefBase对象，留下mRefs对象继续使用。*/if ((mRefs->mFlags & OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK) {if (mRefs->mWeak == 0) {delete mRefs;}...}
}

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

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

相关文章

Android Gralde 新版aar依赖问题解决

Android Gralde 新版aar依赖问题解决

问题&#xff1a;direct local .aar file dependencies are not supported when building an aar. 1.mylibrary 下 build.gradle 文件 .aar文件依赖修改&#xff1a; 之前为&#xff1a; dependencies {implementation fileTree(dir: libs, include: [*.jar,*.aar]) } 更改…
阅读更多...
美客多产品没流量？不要只看广告！

美客多产品没流量？不要只看广告！

都说美客多是巴西电商流量的巅峰平台&#xff0c;然而&#xff0c;不少商家却面临店铺无人问津、流量匮乏的困境。问题或许不仅仅是平台的广告投放。本文将深入剖析美客多平台的运营机制&#xff0c;特别是如何有效提升店铺声誉&#xff0c;从而帮助商家在美客多平台上吸引更多…
阅读更多...
ARM（5）内存管理单元MMU

ARM（5）内存管理单元MMU

一、虚拟地址和物理地址 首先&#xff0c;计算机系统的内存被组成一个由M个连续的字节大小组成的数组。每字节都会有一个唯一的物理地址。CPU访问内存最简单的方式就是使用物理地址。如下图&#xff1a; 图 1 物理地址,物理寻址 而现在都是采用的都是虚拟寻址的方法。CPU生成一…
阅读更多...
gitlab保护分支设置

gitlab保护分支设置

版本&#xff1a;gitlab10.2.2 一旦设置master分支被保护&#xff0c;除了管理员之外的任何用户都无法直接向master提交代码&#xff0c;只要提交代码就会报错 # git push -u origin master Total 0 (delta 0), reused 0 (delta 0) remote: GitLab: You are not allowed to pu…
阅读更多...
在CentOS系统下实现准实时SFTP上传指定目录下前2分钟的文件

在CentOS系统下实现准实时SFTP上传指定目录下前2分钟的文件

在CentOS系统下实现准实时SFTP上传指定目录下前2分钟的文件 引言准备工作编写Shell脚本执行脚本定时执行脚本注意事项结论引言 在企业级的文件同步和备份场景中，经常需要将本地目录中最新生成的文件（如前2分钟内生成的文件）快速上传到远程服务器的指定目录。为了实现这一目…
阅读更多...
雷达各个波段

雷达各个波段

毫米波、微波和可见光的频率范围和波段划分如下&#xff1a; 1. 毫米波&#xff08;Millimeter Waves&#xff09; 频率范围&#xff1a;30 GHz - 300 GHz波长范围&#xff1a;1 mm - 10 mm波段划分&#xff1a; 低毫米波&#xff1a;30 GHz - 60 GHz &#xff08;波长 5 mm …
阅读更多...
unity 屏幕波动反馈打击效果（附资源下载）

unity 屏幕波动反馈打击效果（附资源下载）

unity 屏幕波动反馈打击效果 一枪打出去整个屏幕都回波动的效果反馈。 知识点&#xff1a; 1、动画事件 2、屏幕后处理 效果如图&#xff1a;&#xff08;波动速度浮动都可调整&#xff09; 附件下载
阅读更多...
回头看以及向后看

回头看以及向后看

回头看 昨天看了 大概一百个新生&#xff0c; 看到一百多个新生来了解python&#xff0c;一百多个人里有的可以根据给的相关教程很快的把ide和python解释器安装上&#xff0c;有的就出现了一堆一堆的问题&#xff0c;甚至有的连U盘都不知道怎么用&#xff0c;对着HDMI接口库库使…
阅读更多...
【互联网业务风控】

【互联网业务风控】

1. 不同场景下的业务风控 1.1 账户业务风控 1.1.1账户安全 • 账号安全是所有强账号体系应用的基础&#xff0c; 强账号体系&#xff0c;如电商、网游、第三方支付、社交网络、即时通讯等&#xff1b;是需要登录后产生数据和交互的应用&#xff0c; 弱账号体, 如搜索、导航、…
阅读更多...
关键词提取技术：TF-IDF 和 TextRank 简介

关键词提取技术：TF-IDF 和 TextRank 简介

关键词提取是自然语言处理中的重要任务之一&#xff0c;用于自动提取文档中最能代表其内容的词汇。两种常用的关键词提取技术是 TF-IDF 和 TextRank。它们的工作机制和应用场景有所不同&#xff0c;下面将详细解释这两种技术。 1. TF-IDF&#xff08;Term Frequency - Inverse…
阅读更多...
Python | Leetcode Python题解之第485题最大连续1的个数

Python | Leetcode Python题解之第485题最大连续1的个数

题目&#xff1a; 题解&#xff1a; class Solution:def findMaxConsecutiveOnes(self, nums: List[int]) -> int:maxCount count 0for i, num in enumerate(nums):if num 1:count 1else:maxCount max(maxCount, count)count 0maxCount max(maxCount, count)return …
阅读更多...
未来智慧建筑：人工智能技术的无限可能

未来智慧建筑：人工智能技术的无限可能

随着科技的不断发展&#xff0c;人工智能技术正逐渐渗透到各行各业&#xff0c;其中&#xff0c;在智能建筑领域的应用备受瞩目。智能建筑结合了传统建筑与先进科技的完美融合&#xff0c;在提高建筑效率、节能环保、增强安全性等方面发挥着重要作用。本文将探讨人工智能技术在…
阅读更多...
鹏哥C语言83-85---结构体声明+初始化+访问+传参

鹏哥C语言83-85---结构体声明+初始化+访问+传参

#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h> //---------------------------------------------------------------------------------------------------BIT-7-结构体 1.结构体的声明 1.1结构的基础知识 1.2结构的声明 …
阅读更多...
MyBatis的占位符（day36）

MyBatis的占位符（day36）

1 学习目标 重点掌握#{}占位符的使用 2 MyBatis的占位符介绍 #{}占位符: 相当于JDBC中的问号(?)占位符&#xff0c;是为SQL语句中的值进行占位&#xff0c;如果参数值是字符串或者日期类型&#xff0c;会进行转义处理 我们使用#{}写的SQL语句: <update id"delete…
阅读更多...
蓝牙资讯|苹果AirPods Pro 2耳机推送开发者Beta固件

蓝牙资讯|苹果AirPods Pro 2耳机推送开发者Beta固件

科技媒体 MacRumors 报道&#xff0c;苹果公司邀请开发者&#xff0c;针对 Lightning 和 USB-C 接口的 AirPods Pro 2 耳机&#xff0c;推送了新的 7B5013d 固件版本&#xff0c;较之前的 7B5013c 有所提升。 苹果未来会向所有 AirPods Pro 2 用户推送本次固件更新&#xff0…
阅读更多...
react18中实现简易增删改查useReducer搭配useContext的高级用法

react18中实现简易增删改查useReducer搭配useContext的高级用法

useReducer和useContext前面有单独介绍过&#xff0c;上手不难&#xff0c;现在我们把这两个api结合起来使用&#xff0c;该怎么用&#xff1f;还是结合之前的简易增删改查的demo&#xff0c;熟悉vue的应该可以看出&#xff0c;useReducer类似于vuex&#xff0c;useContext类似…
阅读更多...
springboot项目通过maven的profile功能实现通过不同文件夹的方式来组织不同环境配置文件

springboot项目通过maven的profile功能实现通过不同文件夹的方式来组织不同环境配置文件

写在前面 本文看下springboot项目如何通过文件夹的方式来组织不同环境配置文件。 1&#xff1a;正文 一般的我们写springboot项目时配置文件是这个样子的&#xff1a; appliction.yaml --> 通过spring.profiles.activexxx来激活某个指定后缀的配置文件 application-evn1…
阅读更多...
使用Python语言结合OpenCV库来处理视频流和条形码/二维码的识别

使用Python语言结合OpenCV库来处理视频流和条形码/二维码的识别

使用Python语言结合OpenCV库来处理视频流和条形码/二维码的识别，并使用PyQt5库来构建GUI界面。 安装必要的库 首先，确保你已经安装了所需的库： pip install opencv-python pyzbar PyQt5import sys import time import cv2 from pyzbar.pyzbar import decode from PyQt5.QtW…
阅读更多...
小程序项目实践（一）--项目的初始化以及前期的准备工作

小程序项目实践（一）--项目的初始化以及前期的准备工作

目录 1.起步 1.1 uni-app 简介 1.2 开发工具 1.2.1 下载 HBuilderX 1.2.2 安装 HBuilderX 1.2.3 安装 scss/sass 编译 1.2.4 快捷键方案切换 1.2.5 修改编辑器的基本设置 1.3 新建 uni-app 项目 1.4 目录结构 1.5 把项目运行到微信开发者工具 1.6 使用 Git 管理项目 …
阅读更多...
SpringBoot3响应式编程全套-R2DBC

SpringBoot3响应式编程全套-R2DBC

目录 传送门前言一、R2DBC概念二、Spring Data R2DBC1、整合1.1、导入依赖1.2、编写配置 2、声明式接口&#xff1a;R2dbcRepository2.1、Repository接口2.2、自定义Converter2.3、配置生效 3、编程式组件 三、RBAC-SQL练习1、1-12、1-N 四、最佳实践五、附录 传送门 SpringMV…
阅读更多...
最新文章

Copyright @ 2022~2023