在 Java 中伪造堆栈跟踪
当您在 Java 中使用 RMI 时，异常的远程堆栈跟踪将在您收到异常时预先添加，有点像这样：
ERROR Client received error when doing stuff:
myapp.FooBarException: bla
at server.myMethod()
at rmi.callHandler() // and now, on the next line comes the client
at rmi.sendCall();
at client.doServerMethod()
at Thread.run()
这种堆栈跟踪“伪造”是如何完成的？
我想要它做什么（除了被迭代之外）？好吧，如果我能做到这一点，它将对我有所帮助：
outer() {
thread = new Thread(...
inner();
// inner() throws
// RuntimeException
// at inner();
// at Runnable.run();
// at Thread.run();
// at outer();
// at lalalala();
// ...
).start();
thread.join();
}
并使其在 inner() 中抛出的异常将具有 outer() （以及链下游的方法) 也在堆栈跟踪中，用于记录目的。
When you use RMI in Java the remote stack trace of an exception will be prepended when you receive it, somewhat like this:
ERROR Client received error when doing stuff:
myapp.FooBarException: bla
at server.myMethod()
at rmi.callHandler() // and now, on the next line comes the client
at rmi.sendCall();
at client.doServerMethod()
at Thread.run()
How is that kind of stacktrace "forgery" done?
What do I want it for (apart from just being iterested)? Well, it would help me if I could do this:
outer() {
thread = new Thread(...
inner();
// inner() throws
// RuntimeException
// at inner();
// at Runnable.run();
// at Thread.run();
// at outer();
// at lalalala();
// ...
).start();
thread.join();
}
And make it so that an exception thrown in inner() would have outer() (and methods lower down the chain) in the stacktrace as well, for logging purposes.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（3）
这很简单：
Throwable 有方法
getStackTrace()和setStackTrace()。来自我的一个项目（非开源，但也许有一天我会打开远程调用引擎）：
为方便起见，翻译为：
（在服务器端，我已经切断了与方法调用本身无关的堆栈跟踪部分，即与消息处理相关的所有内容。）
这会产生如下组合堆栈跟踪：
我想RMI 系统做的事情非常相似（只是没有<代码>══════════════════════════）。
编辑：
对于您的用例，您必须在启动内部线程时保存外部线程的堆栈跟踪，然后在 run 方法中捕获异常并将外部堆栈跟踪附加到内部异常的堆栈跟踪。不过，我真的建议放置某种类型的分隔符。
It is kind of easy:
Throwable has methods
getStackTrace()andsetStackTrace().From one of my projects (non open-source, but maybe I'll some day open the remote call engine):
Translated for your convenience:
(On the server side, I'm already cutting off the parts of the stack trace which do not relate to the method call itself, i.e. everything related to the message handling.)
This results in a combined stack trace like this:
I suppose the RMI system does something quite similar (just without the
══════════════════════════).Edit:
For your usecase, you would have to save the stack trace of the outer thread when the inner thread is started, then in the run method catch the exception and append the outer stack trace to the stack trace of the inner exception. I would really recommend putting some type of separator, though.
您创建一个自定义异常，从一个异常中提取堆栈跟踪，并通过 setStackTrace() 将其添加到另一个异常中。
当您不想维护对异常引起的硬引用时，它对于执行此类操作或维护堆栈跟踪非常有用。当将异常信息从服务器传递到客户端时，这很方便，其中根本原因异常类可能不存在，从而导致序列化问题。
You create a customized exception that extracts the stacktrace from one exception and adds it to another via setStackTrace().
It's useful for doing things like this or maintaining a stacktrace when you don't want to maintain a hard reference to the caused by exception. This is handy when passing exception info from server to client where the root cause exception classes may not be present, thus causing serialization issues.
我想建议一个替代解决方案，这不是OP所要求的，但对于一些有非常相似问题的人来说可能更好。像我这样的。
我建议在外部创建一个可抛出的对象，并添加内部可抛出的对象作为外部可抛出对象的原因。这还将捕获进行线程切换的点...这可能有助于避免堆栈跟踪的混乱。此外，线程信息可以存储在外部创建的 Throwable 中，这可能会有更多帮助。
这是一些代码。
然后使用这样的代码：
I would like to suggest an alternative solution, which isn't what the OP asked for, but may be better for some people that have a very similar question. Like me.
I suggest creating a throwable in outer and add the throwable from inner as the cause of the throwable from outer. This will also capture the point at which a thread switch was made... which may be useful to avoid confusion about the stack trace. Furthermore, thread information can be stored in this throwable created in outer that may help even more.
Here's some code.
Then use the code like this: