深入解读 Android Hook 技术-从原理到实践


在Android开发中，Hook技术是一种强大的手段，它允许开发者拦截和修改系统或应用的行为。通过Hook，我们可以在事件传递的过程中插入自定义的逻辑，从而实现对应用行为的监控和修改。

Android 系统有自己的事件分发机制，所有的代码调用和回调都遵循一定的顺序执行。Hook 技术的作用就在于，可以在事件传送到终点前截获并监控该事件的传输，并进行自定义的处理。

本文将深入探讨Hook技术的原理、应用场景以及如何实现它，带你一窥Android应用背后的神秘力量。


一、Hook技术的定义


Hook技术，源自计算机编程中的“钩子”概念，是一种在程序执行过程中动态改变程序行为的技术，是一种允许用户或开发者拦截和处理系统事件或方法调用的技术。它通过在程序执行路径中插入自定义的代码片段，从而能够实现对程序行为的拦截和修改。


具体来说，Hook 技术主要包括以下几个特点:

  1. 动态修改: Hook 技术是在程序运行时进行修改，而不是在编译时。这使得它可以灵活地应用于各种场景，而不需要修改程序源码。
  2. 透明性: 使用 Hook 技术进行修改是透明的，对于程序的其他部分来说是不可见的。这有利于保持程序的整体一致性和稳定性。
  3. 可扩展性: Hook 技术可以用于各种程序功能的扩展和增强，例如系统监控、性能分析、安全检测等。
  4. 多样性: Hook 技术可以应用于不同的编程语言和平台，包括 Windows、Linux、macOS 等。它通常利用操作系统或运行时环境提供的钩子机制来实现。

在 Java 中，常见的 Hook 技术包括:

  1. 使用反射修改现有类的方法实现
  2. 利用动态代理创建代理对象
  3. 通过 Java Instrumentation 接口修改类的字节码
  4. 利用 Java 的 SecurityManager 进行权限控制

通过这些技术，我们可以在不修改程序源码的情况下，动态地拦截和修改程序的行为，从而实现各种功能扩展和系统监控的需求。


二、Hook技术的应用场景


在Android系统中，Hook技术通常用于以下几个方面：

1、拦截系统事件：如按键事件、触摸事件等

使用 Java AWT/Swing 事件监听器:

在 AWT/Swing 中，可以为KeyListener接口添加实现，并注册到需要监听的组件上。

这样可以监听键盘事件，并在事件发生时进行自定义处理。

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;public class HookKeyEvents extends JFrame {public HookKeyEvents() {setTitle("Hook Key Events");setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setSize(400， 300);JPanel panel = new JPanel();panel.addKeyListener(new CustomKeyListener());panel.setFocusable(true);getContentPane().add(panel);}private class CustomKeyListener implements KeyListener {@Overridepublic void keyPressed(KeyEvent e) {System.out.println("Key pressed: " + KeyEvent.getKeyText(e.getKeyCode()));// 在这里添加自定义的按键处理逻辑}@Overridepublic void keyReleased(KeyEvent e) {System.out.println("Key released: " + KeyEvent.getKeyText(e.getKeyCode()));}@Overridepublic void keyTyped(KeyEvent e) {System.out.println("Key typed: " + e.getKeyChar());}}public static void main(String[] args) {SwingUtilities.invokeLater(() -> new HookKeyEvents().setVisible(true));}
}

2、修改系统行为：如改变系统设置、拦截系统调用等

  • 使用 Java 的反射机制可以修改现有类的方法实现。

    例如，可以拦截 FileInputStream的read()方法，并在执行原有逻辑前后添加自定义行为。

    import java.io.FileInputStream;
import java.lang.reflect.Method;public class HookFileInputStream {public static void main(String[] args) throws Exception {// 获取 FileInputStream 的 read() 方法Method readMethod = FileInputStream.class.getDeclaredMethod("read");// 创建一个代理方法，实现自定义逻辑readMethod.invoke(new FileInputStream("example.txt")， new Object[0]);}private static Object proxyRead(Object instance， Method method， Object[] args) throws Throwable {System.out.println("Before reading file");Object result = method.invoke(instance， args);System.out.println("After reading file");return result;}
}

3、增强应用功能：如实现应用插件化、动态加载等

插件可以扩展应用程序的功能，比如添加新的菜单项或者修改应用程序的行为。

以下案例演示，如何使用 Java 的反射机制和动态代理来实现插件动态加载。


第一步，定义一个简单的应用程序类:

public class Application {private List<Plugin> plugins = new ArrayList<>();public void addPlugin(Plugin plugin) {plugins.add(plugin);plugin.onPluginLoaded();}public void removePlugin(Plugin plugin) {plugins.remove(plugin);plugin.onPluginUnloaded();}public void run() {System.out.println("Running application...");for (Plugin plugin : plugins) {plugin.doSomething();}}
}

第二步，定义一个插件接口:

public interface Plugin {void onPluginLoaded();void onPluginUnloaded();void doSomething();
}

第三步，创建一个简单的插件实现:

public class ExamplePlugin implements Plugin {@Overridepublic void onPluginLoaded() {System.out.println("ExamplePlugin loaded.");}@Overridepublic void onPluginUnloaded() {System.out.println("ExamplePlugin unloaded.");}@Overridepublic void doSomething() {System.out.println("ExamplePlugin doing something.");}
}

第四步，我们创建一个 PluginLoader 类，它使用 Java 的反射机制和动态代理来动态加载和卸载插件:

public class PluginLoader {public static void loadPlugin(Application app， String pluginClassName) throws Exception {Class<?> pluginClass = Class.forName(pluginClassName);Plugin plugin = (Plugin) pluginClass.getDeclaredConstructor().newInstance();app.addPlugin(plugin);}public static void unloadPlugin(Application app， String pluginClassName) throws Exception {Class<?> pluginClass = Class.forName(pluginClassName);Plugin plugin = (Plugin) Proxy.newProxyInstance(PluginLoader.class.getClassLoader()，new Class<?>[]{Plugin.class}，(proxy， method， args) -> {System.out.println("Unloading plugin: " + pluginClassName);app.removePlugin((Plugin) proxy);return null;});plugin.onPluginUnloaded();}
}

第五步，在应用程序中动态加载和卸载插件:

public class Main {public static void main(String[] args) {Application app = new Application();try {PluginLoader.loadPlugin(app， "ExamplePlugin");app.run();PluginLoader.unloadPlugin(app， "ExamplePlugin");app.run();} catch (Exception e) {e.printStackTrace();}}
}

在这个例子中，我们使用 PluginLoader 类来动态加载和卸载 ExamplePlugin。当插件被加载时，它会被添加到应用程序中，并调用 onPluginLoaded() 方法。当插件被卸载时，它会被从应用程序中移除，并调用 onPluginUnloaded() 方法。


三、Hook技术的工作原理

Android Hook技术的核心在于方法拦截。

它通过以下几个步骤实现：

  1. 获取目标方法或对象: 首先需要确定需要拦截的目标方法或对象。这可以通过反射或动态代理等技术来实现。
  2. 创建代理类或方法: 创建一个代理类或方法，用于在目标方法或对象被调用时执行自定义的逻辑。
  3. 替换或修改目标: 将原有的目标方法或对象替换为代理类或方法，使得后续的调用都会指向代理。
  4. 执行自定义逻辑: 在代理类或方法中执行自定义的逻辑，例如记录日志、修改参数、改变返回值等。
  5. 可选:恢复原状: 在某些情况下，可能需要在使用完 Hook 技术后将目标方法或对象恢复到原来的状态。

下面我们来看一个完整的案例，演示如何使用 Java 的 Hook 技术来拦截文件读取操作:

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class HookFileInputStream {public static void main(String[] args) {try {// 1. 获取 FileInputStream 的实例FileInputStream fis = new FileInputStream("example.txt");// 2. 创建代理类FileInputStreamProxy proxy = new FileInputStreamProxy(fis);// 3. 获取 FileInputStream 的 read() 方法Method readMethod = FileInputStream.class.getDeclaredMethod("read");// 4. 创建动态代理对象FileInputStream proxyFis = (FileInputStream) Proxy.newProxyInstance(HookFileInputStream.class.getClassLoader()，new Class<?>[]{FileInputStream.class}，proxy);// 5. 执行读取操作int data = proxyFis.read();System.out.println("Read data: " + data);} catch (Exception e) {e.printStackTrace();}}private static class FileInputStreamProxy implements InvocationHandler {private final FileInputStream fileInputStream;public FileInputStreamProxy(FileInputStream fileInputStream) {this.fileInputStream = fileInputStream;}@Overridepublic Object invoke(Object proxy， Method method， Object[] args) throws Throwable {// 在目标方法执行前执行自定义逻辑System.out.println("Before reading file");// 执行目标方法Object result = method.invoke(fileInputStream， args);// 在目标方法执行后执行自定义逻辑System.out.println("After reading file");return result;}}
}

在这个案例中，我们使用以下步骤实现了 Hook 技术:

  1. 首先，我们获取了一个 FileInputStream 的实例，这是我们需要拦截的目标对象。
  2. 然后，我们创建了一个代理类 FileInputStreamProxy。这个代理类实现了 InvocationHandler 接口，用于在目标方法被调用时执行自定义逻辑。
  3. 接下来，我们通过反射获取了 FileInputStream 的 read() 方法。这是我们需要拦截的目标方法。
  4. 使用 Java 的动态代理机制，我们创建了一个代理对象 proxyFis。这个代理对象会在调用任何 FileInputStream 方法时，都将调用 FileInputStreamProxy 的 invoke() 方法。
  5. 最后，我们调用了代理对象的 read() 方法，在方法执行前后分别输出了一些自定义的日志信息。

四、Hook技术的关键组件

Hook 技术的关键组件主要包括以下几个部分:

  1. 目标对象/方法: 需要被拦截和修改的系统对象或方法。这是 Hook 技术的核心所在。通常可以通过反射或动态代理等机制获取目标对象或方法。
  2. 代理对象/方法: 用于替换原有的目标对象或方法，并在目标被调用时执行自定义逻辑的代理实现。代理可以是一个单独的类，也可以是一个动态生成的代理对象。
  3. 替换机制: 将原有的目标对象或方法替换为代理对象或方法的机制。这可以通过修改对象的成员变量、重写类的方法、使用动态代理等方式实现。
  4. 自定义逻辑: 在代理对象或方法中执行的自定义逻辑。这是 Hook 技术的核心价值所在，可以包括记录日志、修改参数、改变返回值等各种功能。
  5. 恢复机制: 有时需要在使用完 Hook 技术后，将系统恢复到原来的状态。这需要提供一种方法来撤销之前的修改，比如保存原有状态并在合适的时候恢复。

下面我们来看一个更加详细的 Java 代码示例，演示这些关键组件的使用:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 1. 目标对象
class TargetObject {public void doSomething() {System.out.println("TargetObject is doing something.");}
}// 2. 代理对象
class ProxyObject implements InvocationHandler {private final Object targetObject;public ProxyObject(Object target) {this.targetObject = target;}@Overridepublic Object invoke(Object proxy， Method method， Object[] args) throws Throwable {// 3. 自定义逻辑System.out.println("Before calling method: " + method.getName());// 4. 执行原始方法Object result = method.invoke(targetObject， args);// 3. 自定义逻辑System.out.println("After calling method: " + method.getName());return result;}
}// 5. 替换机制
public class HookExample {public static void main(String[] args) {// 1. 获取目标对象TargetObject target = new TargetObject();// 2. 创建代理对象ProxyObject proxy = new ProxyObject(target);// 5. 替换机制 - 使用动态代理TargetObject proxyTarget = (TargetObject) Proxy.newProxyInstance(TargetObject.class.getClassLoader()，new Class<?>[]{TargetObject.class}，proxy);// 调用目标对象proxyTarget.doSomething();// 5. 恢复机制 (可选)// 在某些情况下，可能需要将目标对象恢复到原来的状态}
}

在这个例子中，我们演示了 Hook 技术的 5 个关键组件:

  1. 目标对象: 我们定义了一个 TargetObject 类，作为需要被拦截的目标对象。
  2. 代理对象: 我们创建了一个 ProxyObject 类，它实现了 InvocationHandler 接口，用于在目标方法被调用时执行自定义逻辑。
  3. 自定义逻辑: 在 ProxyObject 的 invoke() 方法中，我们添加了在目标方法调用前后执行的自定义逻辑。
  4. 执行原始方法: 在 invoke() 方法中，我们使用 method.invoke() 来调用原始的目标方法。
  5. 替换机制: 我们使用 Java 的动态代理机制，将原有的 TargetObject 实例替换为代理对象 proxyTarget。这样，所有对 TargetObject 的调用都会被 ProxyObject 拦截和处理。

此外，我们还提到了恢复机制，即在某些情况下需要将目标对象恢复到原来的状态。这可以通过保存原始对象的引用，并在适当的时候替换回去来实现。


通过这个例子，你应该能够清楚地理解 Hook 技术的关键组件及其在 Java 中的具体实现方式。这种技术可以让你在不修改系统源码的情况下，动态地修改系统的行为，从而实现各种功能扩展和监控需求。


五、实战案例：Activity 插件化实现


在现代 Android 开发中，模块化和插件化设计理念备受青睐。通过插件化技术，我们可以在不修改主 App 的情况下动态加载外部代码，实现功能热插拔。其中，Activity 插件化是一个重要的课题， 这里将详细介绍如何利用 Hook 技术来实现这一目标。


1、Activity 启动流程剖析

在着手实现之前，我们有必要了解一下 Activity 的启动流程。

简单来说，当我们调用 startActivity 方法时，Android 系统会执行以下几个主要步骤:

  • （1）、Instrumentation 的 execStartActivity 方法被调用
  • （2）、经过层层调用后，最终会执行到 ActivityManagerService(AMS) 的 startActivity 方法
  • （3）、AMS 进行权限校验，资源校验等一系列检查
  • （4）、AMS 通过 Binder 机制调用 ActivityThread 的 scheduleLaunchActivity 方法
  • （5）、ActivityThread经过一系列准备步骤后，调用Instrumentation的newActivity 方法实例化目标 Activity
  • （6）、最后回调目标 Activity 的 onCreate` 等生命周期方法

我们可以发现，想要 Hook 住一个 Activity，最理想的切入点就是在 AMS 的校验之前将目标 Activity 替换成我们想要加载的插件 Activity。


2、自定义 Instrumentation 实现 Hook

Android 为我们提供了 Instrumentation 类，方便在应用程序进程之外监控、修改应用的行为。我们可以通过继承 Instrumentation 并覆写 newActivity 方法，在目标 Activity 实例化前将其替换成我们想要的插件 Activity:

public class MyInstrumentation extends Instrumentation {private ActivityThread origin;@Overridepublic Activity newActivity(ClassLoader cl， String className， Intent intent) throws InstantiationException， IllegalAccessException， ClassNotFoundException {PluginInfo plugin = PluginManager.getInstance().getPlugin(intent);if (plugin != null) {intent.setClassName(plugin.getPackageName()， plugin.getActivityClassName());}if (origin == null) {try {// 反射获取 ActivityThread 实例Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");currentActivityThreadMethod.setAccessible(true);origin = (ActivityThread) currentActivityThreadMethod.invoke(null);// 使用原始 Instrumentation 创建 Activityreturn origin.getInstrumentation().newActivity(cl， intent.getComponent().getClassName()， intent);} catch (Exception e) {e.printStackTrace();}}return super.newActivity(cl， className， intent);}
}

在上面的代码中，我们首先检查目标 Activity 是否需要插件化。如果是，则使用插件包名和 Activity 类名替换原始 Intent 中的值。接着，为了确保非插件化 Activity 的正常启动，我们通过反射获取 ActivityThread 实例，调用其 getInstrumentation 方法获取原始 Instrumentation，并由原始 Instrumentation 创建 Activity 实例。

接下来，我们需要一种方式在 App 启动时注入我们自定义的 Instrumentation。这里我们以 Android 8.0 为例，需要通过 attachBaseContext 来实现。


3、App 启动时注入自定义的 Instrumentation
public class MyApplication extends Application {@Overrideprotected void attachBaseContext(Context base) {super.attachBaseContext(base);try {// 获取原始 InstrumentationInstrumentation instrumentation = (Instrumentation) base.getPackageManager().getInstrumentationInfo(new ComponentName(base.getPackageName()， Instrumentation.class.getName())， 0).classLoader.loadClass("android.app.Instrumentation").newInstance();// 通过反射将 Instrumentation 设置为我们自定义的 MyInstrumentationActivityThread activityThread = (ActivityThread) getActvityThreadMethod.invoke(getStaticFieldValue(activityThreadClass， "sCurrentActivityThread")， null);setFieldValue(activityThread， "mInstrumentation"， new MyInstrumentation());} catch (Exception e) {e.printStackTrace();}}// 反射相关工具方法private static Object getStaticFieldValue(Class klass， String fieldName) throws NoSuchFieldException， IllegalAccessException {Field field = klass.getDeclaredField(fieldName);field.setAccessible(true);return field.get(null);}private static void setFieldValue(Object instance， String fieldName， Object value) throws NoSuchFieldException， IllegalAccessException {Field field = instance.getClass().getDeclaredField(fieldName);field.setAccessible(true);field.set(instance， value);}private static Method getActvityThreadMethod = getMethod(ActivityThread.class， "currentActivityThread");
}

在 attachBaseContext 中，我们首先获取原始 Instrumentation，然后通过反射将 ActivityThread 的 mInstrumentation 字段设置为我们自定义的 MyInstrumentation 实例。这样一来，当 App 启动时，我们的 Instrumentation 就会生效，实现对 Activity 启动过程的拦截和修改。


4、注册与获取插件 Activity

上面我们已经实现了 Hook 逻辑，接下来需要一种方式注册和获取插件 Activity。这里我们可以定义一个 PluginManager 类，维护一个插件列表:

public class PluginManager {private static PluginManager instance;private Map<String， PluginInfo> plugins = new HashMap<>();public static PluginManager getInstance() {if (instance == null) {synchronized (PluginManager.class) {if (instance == null) {instance = new PluginManager();}}}return instance;}public void registerPlugin(PluginInfo plugin) {plugins.put(plugin.getAction()， plugin);}public PluginInfo getPlugin(Intent intent) {return plugins.get(intent.getAction());}public static class PluginInfo {private String packageName;private String activityClassName;private String action;public PluginInfo(String packageName， String activityClassName， String action) {this.packageName = packageName;this.activityClassName = activityClassName;this.action = action;}// Getter & Setter}
}

使用时，我们只需要提前将插件 Activity 的包名、类名和匹配 Action 注册到 PluginManager 即可:

PluginManager.getInstance().registerPlugin(new PluginManager.PluginInfo("com.example.plugin"，"com.example.plugin.PluginActivity"，"com.example.plugin.ACTION")
);

通过上面的实现，我们成功地利用Hook技术实现了Activity插件化。用户只需在主APP中注册插件Activity，即可在不修改主APP代码的情况下加载插件Activity，实现功能热插拔。这种设计不仅提高了代码的可维护性和扩展性，而且为实现跨APP调用等高级功能打下基础。


六、结语


本文深入探讨了 Android Hook 技术的原理和实践应用，为读者提供了全面的认知和实践指引。Hook 技术作为一种强大的开发手段，在未来的 Android 应用优化和创新中都将发挥重要作用。在下一篇文章中，我们将进一步探讨如何构建一个完善、安全、高效的插件化框架以及 Hook 技术在项目优化中的应用 ，欢迎继续关注并多提宝贵意见!


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

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

相关文章

Leetcode2028. 找出缺失的观测数据

Leetcode2028. 找出缺失的观测数据

Every day a Leetcode 题目来源&#xff1a;2028. 找出缺失的观测数据 解法1&#xff1a;模拟 统计当前 m 个元素的总和 curSum sum(rolls)&#xff0c;总共 mn 个元素和为 total (m n) * mean。 排除 2 种情况&#xff1a; total - curSum > 6 * n&#xff1a;n 个…
阅读更多...
链表(2)反转链表

链表(2)反转链表

题目描述 反转一个单链表。&#xff08;题目来源&#xff09; 思路一 其实&#xff0c;反转一个单向链表&#xff0c;我们可以看成是将链表中的每个结点的指向反向&#xff08;即从后一个结点指向前一个结点&#xff09;。 我们在考虑情况的时候&#xff0c;还是可以先考虑一般…
阅读更多...
【基础计算机网络】应用层

【基础计算机网络】应用层

一、网络应用模型 1.1 客户/服务器模型 1.1.1 工作流程 服务器处于接收请求的状态&#xff0c;客户机发出服务请求&#xff0c;并等待接收结果&#xff0c;服务器收到请求后&#xff0c;分析请求&#xff0c;进行必要的处理&#xff0c;得到结果并发送给客户机客户程序必须知…
阅读更多...
变种水仙花

变种水仙花

变种水仙花 题干要求&#xff1a; 变种水仙花数 - Lily Number&#xff1a;把任意的数字&#xff0c;从中间拆分成两个数字&#xff0c;比如1461 可以拆分成&#xff08;1和461&#xff09;,&#xff08;14和61&#xff09;,&#xff08;146和1),如果所有拆分后的乘积之和等于…
阅读更多...
Ollama 本地大模型框架

Ollama 本地大模型框架

该篇教程主要讲解*Ollama的安装和简单使用* Ollama&#xff1a; 在本地启动并运行大型语言模型。 主要流程目录&#xff1a; 1.安装 2.使用 2.1.下载模型 2.2.简单使用 2.3.中文模型 2.4.中文社区 3.总结 1.安装 创建一个容器 切换”高级视图“ 参考填写 ollama oll…
阅读更多...
java家政上门系统源码，App端采用uniapp开发编写，可打包H5 、微信小程序、微信公众号、Android、IOS等。

java家政上门系统源码，App端采用uniapp开发编写，可打包H5 、微信小程序、微信公众号、Android、IOS等。

家政上门系统是一种通过互联网或移动应用平台&#xff0c;为用户提供在线预约、下单、支付和评价家政服务的系统。该系统整合了家政服务资源&#xff0c;使用户能够便捷地找到合适的服务人员&#xff0c;同时也为家政服务人员提供了更多的工作机会。 本套家政上门系统源码&…
阅读更多...
Golang | Leetcode Golang题解之第120题三角形最小路径和

Golang | Leetcode Golang题解之第120题三角形最小路径和

题目&#xff1a; 题解&#xff1a; func minimumTotal(triangle [][]int) int {n : len(triangle)f : make([]int, n)f[0] triangle[0][0]for i : 1; i < n; i {f[i] f[i - 1] triangle[i][i]for j : i - 1; j > 0; j-- {f[j] min(f[j - 1], f[j]) triangle[i][j]…
阅读更多...
旅游行业：解锁收入增长的新策略！

旅游行业：解锁收入增长的新策略！

随着科技的飞速发展和人们生活水平的提高&#xff0c;旅游行业已成为全球范围内最具活力和潜力的行业之一。然而&#xff0c;在这个充满机遇与挑战的市场中&#xff0c;如何确保收入的持续增长&#xff0c;成为每一家旅游企业都必须面对的问题。在这个背景下&#xff0c;用友BI…
阅读更多...
虚拟现实环境下的远程教育和智能评估系统（七）

虚拟现实环境下的远程教育和智能评估系统（七）

在后端代码的基础上&#xff0c;利用vue框架设计前端界面&#xff0c;至此&#xff0c;用户界面基本成型&#xff0c;后续添加其他进阶功能&#xff1b; 另&#xff0c;前后端交互相关&#xff1a; UsersVO.java package com.roncoo.education.user.feign.interfaces.vo;impor…
阅读更多...
Llama改进之——分组查询注意力

Llama改进之——分组查询注意力

引言 今天介绍LLAMA2模型引入的关于注意力的改进——分组查询注意力(Grouped-query attention,GQA)1。 Transformer中的多头注意力在解码阶段来说是一个性能瓶颈。多查询注意力2通过共享单个key和value头&#xff0c;同时不减少query头来提升性能。多查询注意力可能导致质量下…
阅读更多...
易联众智能自动办理平台,AI赋能让数字政务服务“触手可及”

易联众智能自动办理平台,AI赋能让数字政务服务“触手可及”

“城乡居民参保怎么办”“要去XX省工作了,帮我办理异地就医备案”……通过口语化的文字、语音提问,易联众智能自动办理平台的AI助理都可以准确理解对话,并依据政策文件给出详细回答,人机对话像聊天一样轻松。 近日,宁德市民王先生高兴地说:“过去办理医保业务不懂流程,容易走弯…
阅读更多...
Vue常用自定义指令、纪录篇

Vue常用自定义指令、纪录篇

文章目录 一、元素尺寸发生变化时二、点击元素外自定义指令三、元素拖拽自定义指令四、防抖自定义指令五、节流自定义指令六、权限判断自定义指令 一、元素尺寸发生变化时 使用场景&#xff1a; 当元素的尺寸发生变化时需要去适配一些元素时。 或者在元素尺寸发生变化时要去适配…
阅读更多...
C# 命名空间和 using 指令详解

C# 命名空间和 using 指令详解

在C#编程中&#xff0c;命名空间&#xff08;Namespaces&#xff09;用于组织代码元素&#xff0c;如类、接口、枚举等&#xff0c;以避免命名冲突。using 指令用于导入命名空间&#xff0c;使得代码中可以方便地引用其中的类型&#xff0c;而不必每次都使用完整的命名空间路径…
阅读更多...
WPS/Office(Word、Excel、PPT) 自动测评方法

WPS/Office(Word、Excel、PPT) 自动测评方法

在各高等、中等院校的计算机类课程中,计算机基本应用技能的上机操作考试,广受重视,大为盛行。其中,office(word、excel、ppt)上机考试最为普遍。于是,实现这类Office文档操作的自动阅卷评分,很有必要。本人最近项目上刚好遇到需要解决这种自动评分的问题，所以再次记录下解决的…
阅读更多...
TiDB学习9：Ti Cloud简介

TiDB学习9：Ti Cloud简介

目录 1. 为什么选择TiDB 2. 多租户 3. TiDB架构 4. 什么是TiDB Cloud 5. TiDB Cloud Provider Region 6. TiDB Cloud 入门 6.1 在浏览器中打开TiDB Cloud 6.2 创建您的账户 6.3 Developer Tier 与Dedicated Tier 6.3.1 Developer Tier 6.3.2 Dedicated Tier 6.3.2.…
阅读更多...
[HUBUCTF 2022 新生赛]RSAaaa

[HUBUCTF 2022 新生赛]RSAaaa

题目&#xff1a; EXP 就你小子是黑客&#xff1f; 我忘记怎么解密了&#xff01; 靠你了&#xff0c;大黑阔&#xff01;(536970330703, 65537) message: 473878130775 40132555282 40132555282 94619939727 72818765591 208015808884 42561234694 159353248388 27748063975 1…
阅读更多...
逆天工具一键修复图片，视频去码。简直不要太好用！

逆天工具一键修复图片，视频去码。简直不要太好用！

今天&#xff0c;我要向您推荐一款功能强大的本地部署软件&#xff0c;它能够在您的计算机上一键修复图片和视频&#xff0c;去除令人不悦的码赛克&#xff08;轻度马赛克&#xff09;。这款软件是开源的&#xff0c;并在GitHub上公开可用&#xff0c;您可以免费下载并使用。 …
阅读更多...
Scala 柯里化、sortBy方法

Scala 柯里化、sortBy方法

Scala高级特性 小白的Scala学习笔记 2024/5/30 8:42 文章目录 Scala高级特性柯里化sortBy方法 柯里化 参数可以写在两个括号里面 object TestKeli {def add(a:Int)(b:Int)abdef main(args: Array[String]): Unit {val res add(22)(33)println(res)} }可以填隐式参数&#x…
阅读更多...
vector的功能讲解与底层实现

vector的功能讲解与底层实现

本文主要介绍vector的内容以及使用和模拟实现。 vector在英文翻译中是矢量的意思&#xff0c;但在c中他的本质是一个顺序表&#xff08;容器&#xff09;&#xff0c;是一个类模板&#xff0c;&#xff08;用模板创建变量就要参考我们之前的实例化内容了&#xff09;用可以改变…
阅读更多...
dnsrecon一键开始负载平衡检测（KALI工具系列十四）

dnsrecon一键开始负载平衡检测（KALI工具系列十四）

目录 1、KALI LINUX简介 2、lbd工具简介 3、在KALI中使用lbd 3.1 测试目标域名是否存在负载不平衡 4、总结 1、KALI LINUX简介 Kali Linux 是一个功能强大、多才多艺的 Linux 发行版&#xff0c;广泛用于网络安全社区。它具有全面的预安装工具和功能集&#xff0c;使其成为…
阅读更多...
最新文章

Copyright @ 2022~2023