Java高级反射实战：15个场景化编程技巧与底层原理解析

引用

在Java的世界里，反射机制如同赋予开发者一把“万能钥匙”，它打破了静态编程的边界，让代码在运行时拥有动态获取类信息、操作对象属性和方法的能力。从Spring框架的依赖注入，到MyBatis的SQL映射生成；从JSON序列化的底层实现，到字节码增强的黑科技应用，反射的身影无处不在。

然而，这把“钥匙”虽强大，却也伴随着复杂的使用场景和潜在的性能风险。对于初级开发者来说，反射可能只是面试题中的高频考点；但对进阶工程师而言，深入理解反射高级技巧，是突破技术瓶颈、驾驭复杂系统开发的必经之路。本文将通过15个精心设计的实战案例，结合JVM底层原理剖析，带你解锁反射的高阶玩法，助你在Java编程的道路上更进一步。

一、反射基础：从Class对象到MethodHandle

1.1 Class对象的三种获取方式

在Java中，获取Class对象是使用反射的第一步，主要有三种方式：

  • 类名.class：适用于已知类名，在编译期就确定类型的场景
  • 对象.getClass()：通过实例对象获取其运行时类型
  • Class.forName()：根据全限定类名动态加载类，常用于配置化场景
// 1. 类名.class
Class<?> clazz1 = String.class;// 2. 对象.getClass()
String str = "Hello";
Class<?> clazz2 = str.getClass();// 3. Class.forName()
try {Class<?> clazz3 = Class.forName("java.util.Date");
} catch (ClassNotFoundException e) {e.printStackTrace();
}

值得注意的是，Class.forName()方法会触发类的初始化（执行静态代码块），而前两种方式不会。在获取泛型类型参数时，我们可以这样使用：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;class GenericClass<T> {private List<T> list;public void printType() {Type genericSuperclass = getClass().getGenericSuperclass();if (genericSuperclass instanceof ParameterizedType) {ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();for (Type type : actualTypeArguments) {System.out.println("泛型类型参数: " + type.getTypeName());}}}
}public class Main {public static void main(String[] args) {GenericClass<String> genericClass = newGenericClass<>();genericClass.printType();}
}

1.2 JVM类加载机制深度解析

Java类加载遵循双亲委派模型，即类加载器在加载类时，会先委托父类加载器进行加载，只有当父类加载器无法加载时，才由自身加载。我们可以通过自定义类加载器来实现动态加载外部类：

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;public class CustomClassLoader extends ClassLoader {private String classPath;public CustomClassLoader(String classPath) {this.classPath = classPath;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {byte[] classData = loadClassData(name);if (classData == null) {throw new ClassNotFoundException(name);}return defineClass(name, classData, 0, classData.length);}private byte[] loadClassData(String className) {String fileName = classPath + File.separator + className.replace('.', File.separator) + ".class";try (FileInputStream fis = new FileInputStream(fileName);ByteArrayOutputStream bos = new ByteArrayOutputStream()) {byte[] buffer = new byte[1024];int length;while ((length = fis.read(buffer)) != -1) {bos.write(buffer, 0, length);}return bos.toByteArray();} catch (IOException e) {e.printStackTrace();}return null;}
}

使用时：

public class Main {public static void main(String[] args) throws Exception {CustomClassLoader classLoader = new CustomClassLoader("path/to/classes");Class<?> clazz = classLoader.loadClass("com.example.DynamicClass");Object instance = clazz.getDeclaredConstructor().newInstance();// 调用实例方法}
}

1.3 反射与权限控制

通过setAccessible(true)可以突破Java访问修饰符的限制，访问私有成员：

class PrivateClass {private String privateField = "私有字段";private void privateMethod() {System.out.println("私有方法被调用");}
}public class Main {public static void main(String[] args) throws Exception {PrivateClass privateClass = new PrivateClass();java.lang.reflect.Field field = privateClass.getClass().getDeclaredField("privateField");field.setAccessible(true);System.out.println(field.get(privateClass));java.lang.reflect.Method method = privateClass.getClass().getDeclaredMethod("privateMethod");method.setAccessible(true);method.invoke(privateClass);}
}

setAccessible(true)的底层实现依赖于sun.reflect包中的ReflectionFactory，通过修改accessible标志位来绕过访问控制检查。不过在Java 9+中，sun.reflect包的访问受到限制，需要通过模块系统进行配置。

二、反射高级技巧：15个实战场景

2.1 Spring Bean动态注册：反射实现IOC容器

Spring的@ComponentScan功能可以通过反射来模拟实现。首先定义自定义注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyComponent {
}

然后编写扫描器：

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;public class ClassPathScanner {public static List<Class<?>> scan(String packageName) throws IOException, ClassNotFoundException {List<Class<?>> classes = new ArrayList<>();String path = packageName.replace('.', '/');Enumeration<URL> resources = Thread.currentThread().getContextClassLoader().getResources(path);while (resources.hasMoreElements()) {URL resource = resources.nextElement();File directory = new File(resource.getFile());if (directory.exists()) {File[] files = directory.listFiles();if (files != null) {for (File file : files) {if (file.isFile() && file.getName().endsWith(".class")) {String className = packageName + '.' + file.getName().substring(0, file.getName().length() - 6);Class<?> clazz = Class.forName(className);if (clazz.isAnnotationPresent(MyComponent.class)) {classes.add(clazz);}}}}}}return classes;}
}

最后模拟IOC容器：

import java.util.HashMap;
import java.util.List;
import java.util.Map;public class MyApplicationContext {private Map<String, Object> beanMap = new HashMap<>();public MyApplicationContext(String basePackage) throws Exception {List<Class<?>> classes = ClassPathScanner.scan(basePackage);for (Class<?> clazz : classes) {Object bean = clazz.getDeclaredConstructor().newInstance();beanMap.put(clazz.getSimpleName().toLowerCase(), bean);}}public Object getBean(String name) {return beanMap.get(name);}
}

2.2 MyBatis映射器原理：动态代理与反射结合

MyBatis的Mapper接口通过动态代理实现数据库操作，我们可以手写简易版：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;interface UserMapper {List<User> selectAll();
}class User {private int id;private String name;// 省略getter/setter
}class MapperProxy implements InvocationHandler {private Connection connection;public MapperProxy() throws Exception {Class.forName("com.mysql.cj.jdbc.Driver");connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {String sql = "SELECT * FROM user";PreparedStatement ps = connection.prepareStatement(sql);ResultSet rs = ps.executeQuery();List<User> userList = new ArrayList<>();while (rs.next()) {User user = new User();user.setId(rs.getInt("id"));user.setName(rs.getString("name"));userList.add(user);}return userList;}
}public class Main {public static void main(String[] args) throws Exception {UserMapper userMapper = (UserMapper) Proxy.newProxyInstance(UserMapper.class.getClassLoader(),new Class[]{UserMapper.class},new MapperProxy());List<User> userList = userMapper.selectAll();for (User user : userList) {System.out.println(user.getName());}}
}

2.3 JSON序列化优化：反射绕过私有字段限制

Jackson在处理对象序列化时，会使用反射获取对象的字段和方法。当我们需要对私有字段进行序列化时，可以通过AccessibleObject.setAccessible提升性能：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;class PrivateUser {private int id;private String name;// 省略getter/setterpublic PrivateUser(int id, String name) {this.id = id;this.name = name;}
}public class Main {public static void main(String[] args) throws JsonProcessingException {PrivateUser user = new PrivateUser(1, "Alice");ObjectMapper objectMapper = new ObjectMapper();// 反射设置私有字段可访问java.lang.reflect.Field[] declaredFields = PrivateUser.class.getDeclaredFields();for (java.lang.reflect.Field field : declaredFields) {field.setAccessible(true);}String json = objectMapper.writeValueAsString(user);System.out.println(json);}
}

2.4 MethodHandle vs ReflectiveOperationException

MethodHandle是Java 7引入的新特性，相比传统反射Method.invoke()，它在性能上有显著提升：

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Method;class Calculator {public int add(int a, int b) {return a + b;}
}public class Main {public static void main(String[] args) throws Exception {Calculator calculator = new Calculator();// 传统反射调用Method method = Calculator.class.getMethod("add", int.class, int.class);long startTime = System.currentTimeMillis();for (int i = 0; i < 10000000; i++) {method.invoke(calculator, 1, 2);}long endTime = System.currentTimeMillis();System.out.println("传统反射耗时: " + (endTime - startTime) + "ms");// MethodHandle调用MethodHandles.Lookup lookup = MethodHandles.lookup();MethodHandle handle = lookup.findVirtual(Calculator.class, "add", MethodType.methodType(int.class, int.class, int.class));startTime = System.currentTimeMillis();for (int i = 0; i < 10000000; i++) {handle.invoke(calculator, 1, 2);}endTime = System.currentTimeMillis();System.out.println("MethodHandle耗时: " + (endTime - startTime) + "ms");}
}

MethodHandle通过直接操作字节码，减少了反射调用的中间层，在高频调用场景下性能优势明显。

2.5 反射与字节码操作（ASM/ByteBuddy）

使用ByteBuddy可以动态生成代理类，结合反射实现AOP切面：

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;import java.lang.reflect.Method;class LogInterceptor {public static void before(Method method) {System.out.println("方法 " + method.getName() + " 开始执行");}public static void after(Method method) {System.out.println("方法 " + method.getName() + " 执行结束");}
}class TargetClass {public void targetMethod() {System.out.println("目标方法执行中");}
}public class Main {public static void main(String[] args) {TargetClass proxy = new ByteBuddy().subclass(TargetClass.class).method(ElementMatchers.any()).intercept(MethodDelegation.to(new Object() {public void intercept(TargetClass target, Method method) throws Throwable {LogInterceptor.before(method);method.invoke(target);LogInterceptor.after(method);}})).make().load(TargetClass.class.getClassLoader()).getLoaded().getDeclaredConstructor().newInstance();proxy.targetMethod();}
}

2.6 泛型擦除绕过：反射获取真实类型

在反序列化场景中，我们经常需要获取泛型的真实类型：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;class GenericWrapper<T> {private List<T> list;public GenericWrapper() {list = new ArrayList<>();}public List<T> getList() {return list;}public void add(T element) {list.add(element);}public Type getActualTypeArgument() {Type genericSuperclass = getClass().getGenericSuperclass();if (genericSuperclass instanceof ParameterizedType) {ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;return parameterizedType.getActualTypeArguments()[0];}return null;}
}public class Main {public static void main(String[] args) {GenericWrapper<String> wrapper = new GenericWrapper<>();wrapper.add("Hello");Type actualType = wrapper.getActualTypeArgument();System.out.println("泛型真实类型: " + actualType.getTypeName());}
}

2.7 JVM内部状态查看：反射访问非公开类

在Java 9之前，我们可以通过反射访问sun.misc.Unsafe类，进行一些底层操作：

import sun.misc.Unsafe;import java.lang.reflect.Field;public class UnsafeExample {private static Unsafe getUnsafe() throws Exception {Field field = Unsafe.class.getDeclaredField("theUnsafe");field.setAccessible(true);return (Unsafe) field.get(null);}public static void main(String[] args) throws Exception {Unsafe unsafe = getUnsafe();int[] array = new int[10];long baseOffset = unsafe.arrayBaseOffset(int[].class);System.out.println("数组基地址偏移量: " + baseOffset);}
}

不过在Java 9+中，sun.misc.Unsafe类不再公开，需要通过模块系统配置才能访问。

2.8 类热替换：反射实现运行时类更新

结合Instrumentation API与反射，可以在不重启JVM的情况下更新类定义：

import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;public class ClassReloadAgent {public static void premain(String agentArgs, Instrumentation inst) {try {Class<?> clazz = Class.forName("com.example.HotSwappableClass");// 这里可以加载新的类字节码，然后替换inst.retransformClasses(clazz);} catch (ClassNotFoundException | UnmodifiableClassException e) {e.printStackTrace();}}public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {Class<?> clazz = Class.forName("com.example.HotSwappableClass");Method method = clazz.getDeclaredMethod("hello");method.invoke(clazz.getDeclaredConstructor().newInstance());}
}

2.9 反射与枚举类型：突破values()方法限制

通过反射可以新增枚举常量，但这种做法会破坏单例模式与枚举类型的安全性，仅作技术原理探讨。以下代码演示如何在运行时向枚举类添加新常量：

import java.lang.reflect.Field;enum MyEnum {ONE, TWO;
}public class Main {public static void main(String[] args) throws Exception {// 获取枚举类的$VALUES字段，该字段存储了枚举常量数组Field valuesField = MyEnum.class.getDeclaredField("$VALUES");valuesField.setAccessible(true);MyEnum[] oldValues = (MyEnum[]) valuesField.get(null);// 创建新的数组，长度比原数组多1MyEnum[] newValues = new MyEnum[oldValues.length + 1];System.arraycopy(oldValues, 0, newValues, 0, oldValues.length);// 使用反射创建新的枚举实例Class<?> enumType = MyEnum.class;// 利用Unsafe或反射调用枚举类的私有构造函数Field[] declaredFields = enumType.getDeclaredFields();for (Field field : declaredFields) {if (field.getName().contains("enumConstantDirectory")) {field.setAccessible(true);java.util.Map<?, ?> enumConstantDirectory = (java.util.Map<?, ?>) field.get(null);// 构建新枚举常量MyEnum newEnum = MyEnum.valueOf(enumType, "THREE");newValues[oldValues.length] = newEnum;// 更新$VALUES字段valuesField.set(null, newValues);break;}}// 验证新常量已添加for (MyEnum value : MyEnum.values()) {System.out.println(value);}}
}

需要注意，这种操作在生产环境中可能导致不可预测的问题，并且在Java 9+的模块化系统中受到更多限制。

2.10 数组反射：动态创建多维数组与类型转换

使用Array.newInstance()方法可以动态创建任意维度的数组，并进行类型转换：

import java.lang.reflect.Array;public class ArrayReflectionExample {public static void main(String[] args) {// 创建二维int数组int[][] twoDimArray = (int[][]) Array.newInstance(int.class, 3, 4);for (int i = 0; i < twoDimArray.length; i++) {for (int j = 0; j < twoDimArray[i].length; j++) {twoDimArray[i][j] = i * j;}}// 将List<int[]>转换为Object[][]java.util.List<int[]> listArray = new java.util.ArrayList<>();listArray.add(new int[]{1, 2});listArray.add(new int[]{3, 4});Object[][] objectArray = new Object[listArray.size()][];for (int i = 0; i < listArray.size(); i++) {objectArray[i] = listArray.get(i);}}
}

通过Array.get()和Array.set()方法，还可以在运行时访问和修改数组元素。

2.11 反射与注解：动态解析自定义注解

自定义注解结合反射可以实现强大的元编程能力，比如实现一个简单的缓存注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;// 定义缓存注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Cacheable {String value() default "";
}class CacheService {private static final Map<String, Object> cache = new HashMap<>();public static Object getFromCache(String key) {return cache.get(key);}public static void putInCache(String key, Object value) {cache.put(key, value);}
}class Calculator {@Cacheable("addResult")public int add(int a, int b) {System.out.println("执行加法计算");return a + b;}
}public class Main {public static void main(String[] args) throws Exception {Calculator calculator = new Calculator();Method method = calculator.getClass().getMethod("add", int.class, int.class);if (method.isAnnotationPresent(Cacheable.class)) {Cacheable cacheable = method.getAnnotation(Cacheable.class);String cacheKey = cacheable.value();Object result = CacheService.getFromCache(cacheKey);if (result == null) {result = method.invoke(calculator, 2, 3);CacheService.putInCache(cacheKey, result);}System.out.println("结果: " + result);}}
}

上述代码通过反射解析@Cacheable注解，实现了方法结果的缓存功能。

2.12 反射性能陷阱与避坑指南

虽然反射提供了强大的动态编程能力，但使用不当会带来性能问题：

  1. 频繁获取Method对象：每次调用getMethod()或getDeclaredMethod()都会进行方法查找，建议将Method对象缓存起来。
class PerformanceClass {public void perform() {System.out.println("执行方法");}
}public class Main {private static java.lang.reflect.Method performMethod;static {try {performMethod = PerformanceClass.class.getMethod("perform");} catch (NoSuchMethodException e) {e.printStackTrace();}}public static void main(String[] args) throws Exception {PerformanceClass performanceClass = new PerformanceClass();long startTime = System.currentTimeMillis();for (int i = 0; i < 10000000; i++) {performMethod.invoke(performanceClass);}long endTime = System.currentTimeMillis();System.out.println("缓存Method耗时: " + (endTime - startTime) + "ms");}
}
  1. 多线程环境下的安全问题：反射操作并非线程安全，若多个线程同时访问反射对象，可能出现数据竞争。可以使用WeakReference缓存反射对象，避免内存泄漏。
  2. 访问修饰符突破的风险：使用setAccessible(true)会破坏封装性，可能导致代码难以维护和调试，需谨慎使用。

三、总结

Java反射是一把双刃剑，掌握其高级技巧能够在框架开发、性能优化、系统调试等场景中发挥巨大作用。但同时也需要深入理解其底层原理，规避潜在的风险。通过本文介绍的15个实战技巧，希望能帮助开发者更灵活、高效地运用反射技术，在实际项目中创造更大价值。

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

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

相关文章

构建 MCP 服务器：第 3 部分 — 添加提示

构建 MCP 服务器：第 3 部分 — 添加提示

这是我们构建 MCP 服务器的四部分教程的第三部分。在第一部分中&#xff0c;我们使用基本资源创建了第一个MCP 服务器&#xff1b;在第二部分中&#xff0c;我们添加了资源模板并改进了代码组织。现在&#xff0c;我们将进一步重构代码并添加提示功能。 什么是 MCP 提示&#…
阅读更多...
MySQL 索引优化（Explain执行计划） 详细讲解

MySQL 索引优化（Explain执行计划） 详细讲解

&#x1f91f;致敬读者 &#x1f7e9;感谢阅读&#x1f7e6;笑口常开&#x1f7ea;生日快乐⬛早点睡觉 &#x1f4d8;博主相关 &#x1f7e7;博主信息&#x1f7e8;博客首页&#x1f7eb;专栏推荐&#x1f7e5;活动信息 文章目录 MySQL 索引优化&#xff08;Explain执行计划…
阅读更多...
使用 IntelliJ IDEA 安装通义灵码（TONGYI Lingma）插件，进行后端 Java Spring Boot 项目的用户用例生成及常见问题处理

使用 IntelliJ IDEA 安装通义灵码（TONGYI Lingma）插件，进行后端 Java Spring Boot 项目的用户用例生成及常见问题处理

一、什么是通义灵码&#xff08;TONGYI Lingma&#xff09;&#xff1f; 通义灵码是阿里巴巴推出的智能代码辅助工具&#xff0c;结合大模型技术&#xff0c;支持代码生成、用例生成、代码补全等功能&#xff0c;能极大提升开发效率。 二、在 IDEA 中安装通义灵码插件 打开 In…
阅读更多...
AI编程在BOSS项目的实践经验分享

AI编程在BOSS项目的实践经验分享

前言 在人工智能技术革新浪潮的推动下&#xff0c;智能编程助手正以前所未有的速度重塑开发领域。这些基于AI的代码辅助工具通过智能提示生成、实时错误检测和自动化重构等功能&#xff0c;显著提升了软件工程的全流程效率。无论是初入行业的开发者还是资深程序员&#xff0c;…
阅读更多...
JVM 类加载器 详解

JVM 类加载器 详解

类加载器 两个类来源于同一个 Class文件&#xff0c;被同一个Java虚拟机加载&#xff0c;只要加载它们的类加载器不同&#xff0c;那这两个类就必定不相等 这里所指的“相等”&#xff0c;包括代表类的Class对象的equals()方法、isAssignableFrom()方法、isInstance()方法的返…
阅读更多...
Javascript 编程基础（5）面向对象 | 5.1、构造函数实例化对象

Javascript 编程基础（5）面向对象 | 5.1、构造函数实例化对象

文章目录 一、构造函数实例化对象1、基本语法2、构造函数与原型的关系3、完整的原型链4、构造函数的特点5、prototype与__proto__属性5.1、对象实例的__proto__属性5.2、prototype属性仅存在于函数对象5.3、实例与原型的关系5.4、获取对象原型 6、注意事项 前言&#xff1a; 在…
阅读更多...
自动驾驶科普(百度Apollo)学习笔记

自动驾驶科普(百度Apollo)学习笔记

1. 写在前面 在过去的几年里&#xff0c;自动驾驶技术取得飞速发展&#xff0c;人类社会正逐渐走向一个新时代&#xff0c;这个时代中&#xff0c;汽车不仅仅是一个交通工具&#xff0c;更是一个智能的、能够感知环境、做出决策并自主导航的机器伙伴。现在正好也从事这块的工作…
阅读更多...
Windows应用-音视频捕获

Windows应用-音视频捕获

下载“Windows应用-音视频捕获”项目 本应用可以同时捕获4个视频源和4个音频源&#xff0c;可以监视视频源图像&#xff0c;监听音频源&#xff1b;可以将视频源图像写入MP4文件&#xff0c;将音频源写入MP3或WAV文件&#xff1b;还可以录制系统播放的声音。本应用使用MFC对话框…
阅读更多...
MATLAB生成大规模无线通信网络拓扑（任意节点数量）

MATLAB生成大规模无线通信网络拓扑（任意节点数量）

功能&#xff1a; 生成任意节点数量的网络拓扑&#xff0c;符合现实世界节点空间分布和连接规律 效果&#xff1a; 30节点&#xff1a; 100节点&#xff1a; 500节点&#xff1a; 程序&#xff1a; %创建时间&#xff1a;2025年6月8日 %zhouzhichao %自然生长出n节点的网络% …
阅读更多...
TDengine 开发指南—— UDF函数

TDengine 开发指南—— UDF函数

UDF 简介 在某些应用场景中&#xff0c;应用逻辑需要的查询功能无法直接使用内置函数来实现&#xff0c;TDengine 允许编写用户自定义函数&#xff08;UDF&#xff09;&#xff0c;以便解决特殊应用场景中的使用需求。UDF 在集群中注册成功后&#xff0c;可以像系统内置函数一…
阅读更多...
C#提取CAN ASC文件时间戳：实现与性能优化

C#提取CAN ASC文件时间戳：实现与性能优化

C#提取CAN ASC文件时间戳&#xff1a;实现与性能优化 在汽车电子和工业控制领域&#xff0c;CAN总线是最常用的通信协议之一。而ASC&#xff08;ASCII&#xff09;文件作为CAN总线数据的标准日志格式&#xff0c;广泛应用于数据记录和分析场景。本文将深入探讨如何高效地从CAN…
阅读更多...
计算机网络基础总结：TCP/IP 模型、TCP vs UDP、DNS 查询过程

计算机网络基础总结：TCP/IP 模型、TCP vs UDP、DNS 查询过程

在学习计算机网络的过程中&#xff0c;理解 TCP/IP 模型与 OSI 模型的对应关系、掌握 TCP 与 UDP 的区别&#xff0c;以及熟悉 DNS 的查询过程&#xff0c;是打好网络基础的关键。本文将围绕这三部分进行简明扼要的讲解。 一、TCP/IP 模型与 OSI 七层模型的对应关系 1. OSI 七…
阅读更多...
基于PHP的扎染文创产品商城

基于PHP的扎染文创产品商城

有需要请加文章底部Q哦 可远程调试 基于PHP的扎染文创产品商城 一 介绍 扎染文创产品商城系统基于原生PHP开发&#xff0c;数据库mysql&#xff0c;前端bootstrap&#xff0c;jquery.js等。系统角色分为用户和管理员。 技术栈&#xff1a;phpmysqlbootstrapphpstudyvscode 二…
阅读更多...
数据库学习（三）——MySQL锁

数据库学习（三）——MySQL锁

一、MySQL锁 当多个用户或进程并发操作数据库时&#xff0c;为了避免数据冲突、脏读、不可重复读、幻读等问题&#xff0c;数据库通过锁机制来保证数据的一致性和完整性。 MySQL 锁的总体分类&#xff1a; 分类维度类型说明按作用对象表级锁&#xff08;Table Lock&#xff…
阅读更多...
＜3＞-MySQL表的操作

＜3＞-MySQL表的操作

目录 一&#xff0c;创建表 二&#xff0c;查看表结构 三&#xff0c;修改表 四&#xff0c;删除表 一&#xff0c;创建表 语法&#xff1a; CREATE TABLE table_name ( field1 datatype, field2 datatype, field3 datatype ) character set 字符集 collate 校验规则 eng…
阅读更多...
【OSG学习笔记】Day 15: 路径动画与相机漫游

【OSG学习笔记】Day 15: 路径动画与相机漫游

本章来学习下漫游相机。 路径动画与相机漫游 本届内容比较简单&#xff0c;其实就是实现物体的运动和相机的运动 当然这两个要一起执行。 贝塞尔曲线 贝塞尔曲线&#xff08;Bzier curve&#xff09;是一种在计算机图形学、动画制作、工业设计等领域广泛应用的参数曲线&am…
阅读更多...
LabVIEW自感现象远程实验平台

LabVIEW自感现象远程实验平台

LabVIEW开发自感现象远程实验平台&#xff0c;通过整合 NI数据采集设备、菲尼克斯&#xff08;Phoenix Contact&#xff09;继电器模块及罗技&#xff08;Logitech&#xff09;高清摄像头&#xff0c;实现远程数据采集、仪器控制与实时监控三大核心功能。平台突破传统实验装置局…
阅读更多...
数据结构——F/图

数据结构——F/图

一、图的基本概念 图是由顶点集合及顶点间的关系组成的一种数据结构&#xff1a;G (V&#xff0c; E)&#xff0c;其中&#xff1a; 顶点集合V {x|x属于某个数据对象集}是有穷非空集合&#xff1b; E {(x,y)|x,y属于V}或者E {<x, y>|x,y属于V && Path(x, y)…
阅读更多...
springcloud openfeign 偶现 Caused by: java.net.UnknownHostException

springcloud openfeign 偶现 Caused by: java.net.UnknownHostException

背景 最近查看日志发现某服务偶现Caused by: java.net.UnknownHostException 同时查看eureka的access.log 出现如下异常 10.xxx.xxx.xxx - - [27/May/2025:23:57:29 0800] “PUT /eureka/apps/{appName}/{host}:xxx-job:8082?statusUP&lastDirtyTimestamp1748351637173 H…
阅读更多...
第12篇：数据库中间件日志设计与追踪系统落地实践

第12篇：数据库中间件日志设计与追踪系统落地实践

12.1 引言&#xff1a;中间件日志系统为何如此关键&#xff1f; 数据库中间件作为连接前端应用与后端数据库的“网关”&#xff0c;承载着路由、负载均衡、SQL 改写、权限控制等复杂逻辑。 在出现 性能问题、故障排查、安全审计 等场景中&#xff0c;若没有完善的日志体系&am…
阅读更多...
最新文章

Copyright @ 2022~2023