Java_JDK_日志

简述

个人jar封装,自定义日志接口

实现

项目统一调用接口Log

/**
 * The five logging levels used by Log are (in order):
 * 1. DEBUG (the least serious)
 * 2. INFO
 * 3. WARN
 * 4. ERROR
 * 5. FATAL (the most serious)
 */
public abstract class Log {
	
	private static ILogFactory defaultLogFactory = null;
	
	static {
		init();
	}
	 	
	static void init() {
		if (defaultLogFactory == null) {
			try {
			    //初始化优先查询log4j.jar   没有异常使用jdk
				Class.forName("org.apache.log4j.Logger");
				Class<?> log4jLogFactoryClass = Class.forName("com.xxx.log.Log4jLogFactory");
				defaultLogFactory = (ILogFactory)log4jLogFactoryClass.newInstance();	// return new Log4jLogFactory();
			} catch (Exception e) {
				defaultLogFactory = new JdkLogFactory();
			}
		}
	}
	
	static void setDefaultLogFactory(ILogFactory defaultLogFactory) {
		if (defaultLogFactory == null) {
			throw new IllegalArgumentException("defaultLogFactory can not be null.");
		}
		Log.defaultLogFactory = defaultLogFactory;
	}
	
	public static Log getLog(Class<?> clazz) {
		return defaultLogFactory.getLog(clazz);
	}
	
	public static Log getLog(String name) {
		return defaultLogFactory.getLog(name);
	}
	
	public abstract void debug(String message);
	
	public abstract void debug(String message, Throwable t);
	
	public abstract void info(String message);
	
	public abstract void info(String message, Throwable t);
	
	public abstract void warn(String message);
	
	public abstract void warn(String message, Throwable t);
	
	public abstract void error(String message);
	
	public abstract void error(String message, Throwable t);
	
	public abstract void fatal(String message);
	
	public abstract void fatal(String message, Throwable t);
	
	public abstract boolean isDebugEnabled();

	public abstract boolean isInfoEnabled();

	public abstract boolean isWarnEnabled();

	public abstract boolean isErrorEnabled();
	
	public abstract boolean isFatalEnabled();
}

核心实现-Log4j

org.apache.log4j.Logger 需要引入log4j.jar

/**
 * Log4jLogFactory.
 */
public class Log4jLogFactory implements ILogFactory {
	
	public Log getLog(Class<?> clazz) {
		return new Log4jLog(clazz);
	}
	
	public Log getLog(String name) {
		return new Log4jLog(name);
	}
}

/**
 * Log4jLog.
 */
public class Log4jLog extends Log {
	
	private org.apache.log4j.Logger log;
	private static final String callerFQCN = Log4jLog.class.getName();
	
	Log4jLog(Class<?> clazz) {
		log = org.apache.log4j.Logger.getLogger(clazz);
	}
	
	Log4jLog(String name) {
		log = org.apache.log4j.Logger.getLogger(name);
	}
	
	public static Log4jLog getLog(Class<?> clazz) {
		return new Log4jLog(clazz);
	}
	
	public static Log4jLog getLog(String name) {
		return new Log4jLog(name);
	}
	
	public void info(String message) {
		log.log(callerFQCN, Level.INFO, message, null);
	}
	
	public void info(String message, Throwable t) {
		log.log(callerFQCN, Level.INFO, message, t);
	}
	
	public void debug(String message) {
		log.log(callerFQCN, Level.DEBUG, message, null);
	}
	
	public void debug(String message, Throwable t) {
		log.log(callerFQCN, Level.DEBUG, message, t);
	}
	
	public void warn(String message) {
		log.log(callerFQCN, Level.WARN, message, null);
	}
	
	public void warn(String message, Throwable t) {
		log.log(callerFQCN, Level.WARN, message, t);
	}
	
	public void error(String message) {
		log.log(callerFQCN, Level.ERROR, message, null);
	}
	
	public void error(String message, Throwable t) {
		log.log(callerFQCN, Level.ERROR, message, t);
	}
	
	public void fatal(String message) {
		log.log(callerFQCN, Level.FATAL, message, null);
	}
	
	public void fatal(String message, Throwable t) {
		log.log(callerFQCN, Level.FATAL, message, t);
	}
	
	public boolean isDebugEnabled() {
		return log.isDebugEnabled();
	}
	
	public boolean isInfoEnabled() {
		return log.isInfoEnabled();
	}
	
	public boolean isWarnEnabled() {
		return log.isEnabledFor(Level.WARN);
	}
	
	public boolean isErrorEnabled() {
		return log.isEnabledFor(Level.ERROR);
	}
	
	public boolean isFatalEnabled() {
		return log.isEnabledFor(Level.FATAL);
	}
}

核心实现-JDK

java.util.logging.Logger

/**
 * JdkLogFactory.
 */
public class JdkLogFactory implements ILogFactory {
	
	public Log getLog(Class<?> clazz) {
		return new JdkLog(clazz);
	}
	
	public Log getLog(String name) {
		return new JdkLog(name);
	}
}


/**
 * JdkLog.
 */
public class JdkLog extends Log {

	private java.util.logging.Logger log;
	private String clazzName;
	
	JdkLog(Class<?> clazz) {
		log = java.util.logging.Logger.getLogger(clazz.getName());
		clazzName = clazz.getName();
	}
	
	JdkLog(String name) {
		log = java.util.logging.Logger.getLogger(name);
		clazzName = name;
	}
	
	public static JdkLog getLog(Class<?> clazz) {
		return new JdkLog(clazz);
	}
	
	public static JdkLog getLog(String name) {
		return new JdkLog(name);
	}
	
	public void debug(String message) {
		log.logp(Level.FINE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
	}
	
	public void debug(String message,  Throwable t) {
		log.logp(Level.FINE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
	}
	
	public void info(String message) {
		log.logp(Level.INFO, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
	}
	
	public void info(String message, Throwable t) {
		log.logp(Level.INFO, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
	}
	
	public void warn(String message) {
		log.logp(Level.WARNING, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
	}
	
	public void warn(String message, Throwable t) {
		log.logp(Level.WARNING, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
	}
	
	public void error(String message) {
		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
	}
	
	public void error(String message, Throwable t) {
		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
	}
	
	/**
	 * JdkLog fatal is the same as the error.
	 */
	public void fatal(String message) {
		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
	}
	
	/**
	 * JdkLog fatal is the same as the error.
	 */
	public void fatal(String message, Throwable t) {
		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
	}
	
	public boolean isDebugEnabled() {
		return log.isLoggable(Level.FINE);
	}
	
	public boolean isInfoEnabled() {
		return log.isLoggable(Level.INFO);
	}
	
	public boolean isWarnEnabled() {
		return log.isLoggable(Level.WARNING);
	}
	
	public boolean isErrorEnabled() {
		return log.isLoggable(Level.SEVERE);
	}
	
	public boolean isFatalEnabled() {
		return log.isLoggable(Level.SEVERE);
	}
}

日志工具类

/**
 * LogKit.
 */
public class LogKit {
	
	private static class Holder {
		private static Log log = Log.getLog(LogKit.class);
	}
	
	/**
	 * 当通过 Constants.setLogFactory(...) 或者 
	 * LogManager.me().setDefaultLogFacotyr(...)
	 * 指定默认日志工厂以后,重置一下内部 Log 对象,以便使内部日志实现与系统保持一致
	 */
	public static void synchronizeLog() {
		Holder.log = Log.getLog(LogKit.class);
	}
	
	/**
	 * Do nothing.
	 */
	public static void logNothing(Throwable t) {
		
	}
	
	public static void debug(String message) {
		Holder.log.debug(message);
	}
	
	public static void debug(String message, Throwable t) {
		Holder.log.debug(message, t);
	}
	
	public static void info(String message) {
		Holder.log.info(message);
	}
	
	public static void info(String message, Throwable t) {
		Holder.log.info(message, t);
	}
	
	public static void warn(String message) {
		Holder.log.warn(message);
	}
	
	public static void warn(String message, Throwable t) {
		Holder.log.warn(message, t);
	}
	
	public static void error(String message) {
		Holder.log.error(message);
	}
	
	public static void error(String message, Throwable t) {
		Holder.log.error(message, t);
	}
	
	public static void fatal(String message) {
		Holder.log.fatal(message);
	}
	
	public static void fatal(String message, Throwable t) {
		Holder.log.fatal(message, t);
	}
	
	public static boolean isDebugEnabled() {
		return Holder.log.isDebugEnabled();
	}
	
	public static boolean isInfoEnabled() {
		return Holder.log.isInfoEnabled();
	}
	
	public static boolean isWarnEnabled() {
		return Holder.log.isWarnEnabled();
	}
	
	public static boolean isErrorEnabled() {
		return Holder.log.isErrorEnabled();
	}
	
	public static boolean isFatalEnabled() {
		return Holder.log.isFatalEnabled();
	}
}
### RK3588平台NPU调用方法 #### 创建和初始化NPU环境 为了在RK3588平台上成功调用NPU进行神经网络推理或加速,首先需要确保设备已正确配置并加载了相应的驱动程序。Rockchip的官方固件通常已经预装了RKNPU驱动[^3]。 一旦确认硬件准备就绪,可以通过以下方式创建和初始化NPU环境: ```cpp #include "rknn_api.h" // 初始化模型路径和其他参数 const char* model_path = "./model.rknn"; int ret; rknn_context ctx; ret = rknn_init(&ctx, model_path, 0, 0, NULL); if (ret < 0) { printf("Failed to initialize rknn context\n"); } ``` 这段代码展示了如何使用`rknn_api.h`库来初始化一个RKNN上下文对象,这一步骤对于后续的操作至关重要[^2]。 #### 加载和编译模型 接下来,在实际运行之前还需要加载预先训练好的神经网络模型文件(通常是`.rknn`格式)。此过程涉及读取模型二进制数据,并将其传递给RKNN API以便内部处理和优化。 ```cpp // 假设模型已经被转换成 .rknn 文件格式 char *model_data; // 模型的数据指针 size_t model_size; // 模型大小 FILE *fp = fopen(model_path, "rb+"); fseek(fp, 0L, SEEK_END); model_size = ftell(fp); rewind(fp); model_data = (char *)malloc(sizeof(char)*model_size); fread(model_data, sizeof(unsigned char), model_size, fp); fclose(fp); // 将模型数据传入RKNN API ret = rknn_load_rknn(ctx, &model_data, &model_size); free(model_data); if(ret != 0){ printf("Load Model Failed!\n"); } else{ printf("Model Loaded Successfully.\n"); } ``` 这里说明了从磁盘读取模型文件的具体操作流程,并通过API函数将这些信息提交给了底层框架去解析和设置好用于推断所需的资源[^1]。 #### 执行前向传播计算 当一切准备工作完成后就可以开始真正的预测工作——即让NPU执行一次完整的前向传播运算。这个阶段主要是构建输入张量、启动异步任务以及收集输出结果。 ```cpp float input_tensor[INPUT_SIZE]; // 输入特征图数组 float output_tensors[MAX_OUTPUTS][OUTPUT_SIZE]; // 输出特征图数组 struct rknn_input inputs[] = {{input_tensor}}; struct rknn_output outputs[MAX_OUTPUTS]; for(int i=0;i<NUM_ITERATIONS;++i){ memset(inputs, 0 ,sizeof(struct rknn_input)); memcpy(input_tensor, inputData[i], INPUT_SIZE*sizeof(float)); // 启动推理任务 ret = rknn_run(ctx, nullptr); if(ret!=0){ printf("Inference failed at iteration %d", i); break; } // 获取输出结果 for(size_t j=0;j<num_outputs;++j){ struct rknn_output& out = outputs[j]; size_t bufSize = OUTPUT_SIZE * sizeof(float); void* buffer = malloc(bufSize); ret = rknn_get_output(ctx, j, &out.datatype, &buffer, &bufSize, false); if(!ret && buffer){ memcpy(output_tensors[j], buffer, bufSize); free(buffer); } } } printf("All iterations completed successfully."); ``` 上述片段体现了典型的基于RKNN SDK的应用场景:先准备好待测样本作为输入;接着触发内核中的计算逻辑;最后获取到经过变换后的响应值供下一步分析所用[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值