জাভাতে বর্তমানে সম্পাদনকারী পদ্ধতির নাম পাওয়ার কোনও উপায় আছে কি?
জাভাতে বর্তমানে সম্পাদনকারী পদ্ধতির নাম পাওয়ার কোনও উপায় আছে কি?
উত্তর:
Thread.currentThread().getStackTrace()আপনি যে পদ্ধতি থেকে কল করছেন তার মধ্যে সাধারণত সেই পদ্ধতি থাকবে তবে এতে অসুবিধাগুলি রয়েছে ( জাভাদোক দেখুন ):
কিছু ভার্চুয়াল মেশিন, কিছু পরিস্থিতিতে স্ট্যাক ট্রেস থেকে এক বা একাধিক স্ট্যাক ফ্রেম বাদ দিতে পারে। চরম ক্ষেত্রে, এই থ্রেড সম্পর্কিত কোনও স্ট্যাক ট্রেস তথ্য নেই এমন ভার্চুয়াল মেশিনকে এই পদ্ধতি থেকে শূন্য দৈর্ঘ্যের অ্যারে ফেরত দেওয়ার অনুমতি দেওয়া হয়।
প্রযুক্তিগতভাবে এটি কাজ করবে ...
String name = new Object(){}.getClass().getEnclosingMethod().getName();তবে সংকলনের সময় একটি নতুন বেনামি অভ্যন্তর শ্রেণি তৈরি করা হবে (উদাঃ) YourClass$1.class ) এর । সুতরাং এটি .classপ্রতিটি পদ্ধতির জন্য একটি ফাইল তৈরি করবে যা এই কৌশলটি মোতায়েন করে। অতিরিক্তভাবে রানটাইমের সময় প্রতিটি অনুরোধে একটি অন্যথায় অব্যবহৃত অবজেক্ট উদাহরণ তৈরি করা হয়। সুতরাং এটি একটি গ্রহণযোগ্য ডিবাগ ট্রিক হতে পারে, তবে এটি উল্লেখযোগ্য ওভারহেডের সাথে আসে।
এই কৌশলটির একটি সুবিধা এটি that getEncosingMethod() রিটার্নগুলি java.lang.reflect.Methodটীকাগুলি এবং প্যারামিটারের নাম সহ পদ্ধতির সমস্ত অন্যান্য তথ্য পুনরুদ্ধার করতে ব্যবহার করা যেতে পারে। এটি একই নামের (পদ্ধতি ওভারলোড) দ্বারা নির্দিষ্ট পদ্ধতির মধ্যে পার্থক্য করা সম্ভব করে।
নোট করুন জাভাডক অনুযায়ী getEnclosingMethod() এই একটি SecurityExceptionঅভ্যন্তর শ্রেণি একই শ্রেণীর লোডার ব্যবহার করে লোড করা উচিত নয় । সুতরাং কোনও সুরক্ষা ব্যবস্থাপক উপস্থিত থাকলেও অ্যাক্সেস শর্তাদি পরীক্ষা করার প্রয়োজন নেই।
এটি getEnclosingConstructor()নির্মাণকারীদের জন্য ব্যবহার করা প্রয়োজন । (নামযুক্ত) পদ্ধতির বাইরে থাকা ব্লকগুলির সময়, getEnclosingMethod()ফিরে আসে null।
getEnclosingMethodশ্রেণীর সংজ্ঞায়িত পদ্ধতিটির নাম পাওয়া যায়। this.getClass()আপনাকে কিছুটা সাহায্য করবে না @ Wutzebaer- এর জন্য আপনার এমনকি কেন প্রয়োজন হবে? আপনি ইতিমধ্যে তাদের অ্যাক্সেস আছে।
জানুয়ারী ২০০৯:
একটি সম্পূর্ণ কোড হবে ( @ বোম্বের সতর্কতা অবলম্বন করে ব্যবহার করার জন্য):
/**
* Get the method name for a depth in call stack. <br />
* Utility function
* @param depth depth in the call stack (0 means current method, 1 means call method, ...)
* @return method name
*/
public static String getMethodName(final int depth)
{
final StackTraceElement[] ste = Thread.currentThread().getStackTrace();
//System. out.println(ste[ste.length-depth].getClassName()+"#"+ste[ste.length-depth].getMethodName());
// return ste[ste.length - depth].getMethodName(); //Wrong, fails for depth = 0
return ste[ste.length - 1 - depth].getMethodName(); //Thank you Tom Tresansky
}আরো এই প্রশ্নের ।
ডিসেম্বর ২০১১ আপডেট করুন:
নীল মন্তব্য:
আমি জেআরই 6 ব্যবহার করি এবং আমাকে ভুল পদ্ধতির নাম দেয়।
আমি যদি লিখি তবে এটি কাজ করেste[2 + depth].getMethodName().
0হয়getStackTrace(),1হয়getMethodName(int depth)এবং2প্রার্থনা পদ্ধতি।
কুমারী 47 এর উত্তর ( upvated ) আসলে পদ্ধতির নাম ফিরে পেতে প্রয়োগ করতে সঠিক সূচককে গণনা করে।
StackTraceElementডিবাগিংয়ের উদ্দেশ্যে সমস্ত অ্যারে প্রিন্ট করার চেষ্টা করেছিলেন এবং 'মেন' আসলে সঠিক পদ্ধতি কিনা তা দেখার জন্য?
ste[2 + depth].getMethodName()। 0 হ'ল getStackTrace(), 1 হ'ল getMethodName(int depth)এবং 2 হ'ল উদ্দীপনা পদ্ধতি। আরও দেখুন @ virgo47 এর উত্তর ।
স্ট্যাক ট্রেস সূচীতে সম্ভাব্য পরিবর্তনশীলতা হ্রাস করতে আমরা এই কোডটি ব্যবহার করেছি - এখন কেবল মেথডনেম ইউজে কল করুন:
public class MethodNameTest {
private static final int CLIENT_CODE_STACK_INDEX;
static {
// Finds out the index of "this code" in the returned stack trace - funny but it differs in JDK 1.5 and 1.6
int i = 0;
for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
i++;
if (ste.getClassName().equals(MethodNameTest.class.getName())) {
break;
}
}
CLIENT_CODE_STACK_INDEX = i;
}
public static void main(String[] args) {
System.out.println("methodName() = " + methodName());
System.out.println("CLIENT_CODE_STACK_INDEX = " + CLIENT_CODE_STACK_INDEX);
}
public static String methodName() {
return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX].getMethodName();
}
}ওভাররেঞ্জিনারেড মনে হচ্ছে, তবে জেডিকে 1.5 এর জন্য আমাদের কিছু নির্দিষ্ট নম্বর ছিল এবং আমরা জেডিকে 1.6 এ চলে যাওয়ার পরে কিছুটা অবাক হয়েছিলাম changed এখন এটি জাভা 6/7 তে একই, তবে আপনি কখনই জানেন না। রানটাইম চলাকালীন সেই সূচকে পরিবর্তিত হওয়ার প্রমাণ নয় - তবে আশা করি হটস্পট এতটা খারাপ করবে না। :-)
public class SomeClass {
public void foo(){
class Local {};
String name = Local.class.getEnclosingMethod().getName();
}
}নামের মান foo হবে।
null
এই দুটি বিকল্পই জাভা নিয়ে আমার জন্য কাজ করে:
new Object(){}.getClass().getEnclosingMethod().getName()বা:
Thread.currentThread().getStackTrace()[1].getMethodName()আমি যে দ্রুততম উপায়টি পেয়েছি তা হ'ল:
import java.lang.reflect.Method;
public class TraceHelper {
// save it static to have it available on every call
private static Method m;
static {
try {
m = Throwable.class.getDeclaredMethod("getStackTraceElement",
int.class);
m.setAccessible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
public static String getMethodName(final int depth) {
try {
StackTraceElement element = (StackTraceElement) m.invoke(
new Throwable(), depth + 1);
return element.getMethodName();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}এটি নেটিভ পদ্ধতিটি সরাসরি স্ট্যাকট্রেসএলমেন্ট (ইন গভীরতা) অ্যাক্সেস করে। এবং অ্যাক্সেসযোগ্য পদ্ধতিটি একটি স্ট্যাটিক ভেরিয়েবলে সঞ্চয় করে।
new Throwable().getStackTrace()নিয়েছিল , যখন ব্যবহার করেছেন 5614ms।
নিম্নলিখিত কোড ব্যবহার করুন:
StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
StackTraceElement e = stacktrace[1];//coz 0th will be getStackTrace so 1st
String methodName = e.getMethodName();
System.out.println(methodName);public static String getCurrentMethodName() {
return Thread.currentThread().getStackTrace()[2].getClassName() + "." + Thread.currentThread().getStackTrace()[2].getMethodName();
}এটি ভার্জো 47 এর উত্তরের উপরের (উপরে)।
এটি বর্তমান এবং আমন্ত্রণমূলক শ্রেণি / পদ্ধতির নামগুলি পেতে কিছু স্থিতিশীল পদ্ধতি সরবরাহ করে।
/* Utility class: Getting the name of the current executing method
* /programming/442747/getting-the-name-of-the-current-executing-method
*
* Provides:
*
* getCurrentClassName()
* getCurrentMethodName()
* getCurrentFileName()
*
* getInvokingClassName()
* getInvokingMethodName()
* getInvokingFileName()
*
* Nb. Using StackTrace's to get this info is expensive. There are more optimised ways to obtain
* method names. See other stackoverflow posts eg. /programming/421280/in-java-how-do-i-find-the-caller-of-a-method-using-stacktrace-or-reflection/2924426#2924426
*
* 29/09/2012 (lem) - added methods to return (1) fully qualified names and (2) invoking class/method names
*/
package com.stackoverflow.util;
public class StackTraceInfo
{
/* (Lifted from virgo47's stackoverflow answer) */
private static final int CLIENT_CODE_STACK_INDEX;
static {
// Finds out the index of "this code" in the returned stack trace - funny but it differs in JDK 1.5 and 1.6
int i = 0;
for (StackTraceElement ste: Thread.currentThread().getStackTrace())
{
i++;
if (ste.getClassName().equals(StackTraceInfo.class.getName()))
{
break;
}
}
CLIENT_CODE_STACK_INDEX = i;
}
public static String getCurrentMethodName()
{
return getCurrentMethodName(1); // making additional overloaded method call requires +1 offset
}
private static String getCurrentMethodName(int offset)
{
return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getMethodName();
}
public static String getCurrentClassName()
{
return getCurrentClassName(1); // making additional overloaded method call requires +1 offset
}
private static String getCurrentClassName(int offset)
{
return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getClassName();
}
public static String getCurrentFileName()
{
return getCurrentFileName(1); // making additional overloaded method call requires +1 offset
}
private static String getCurrentFileName(int offset)
{
String filename = Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getFileName();
int lineNumber = Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getLineNumber();
return filename + ":" + lineNumber;
}
public static String getInvokingMethodName()
{
return getInvokingMethodName(2);
}
private static String getInvokingMethodName(int offset)
{
return getCurrentMethodName(offset + 1); // re-uses getCurrentMethodName() with desired index
}
public static String getInvokingClassName()
{
return getInvokingClassName(2);
}
private static String getInvokingClassName(int offset)
{
return getCurrentClassName(offset + 1); // re-uses getCurrentClassName() with desired index
}
public static String getInvokingFileName()
{
return getInvokingFileName(2);
}
private static String getInvokingFileName(int offset)
{
return getCurrentFileName(offset + 1); // re-uses getCurrentFileName() with desired index
}
public static String getCurrentMethodNameFqn()
{
return getCurrentMethodNameFqn(1);
}
private static String getCurrentMethodNameFqn(int offset)
{
String currentClassName = getCurrentClassName(offset + 1);
String currentMethodName = getCurrentMethodName(offset + 1);
return currentClassName + "." + currentMethodName ;
}
public static String getCurrentFileNameFqn()
{
String CurrentMethodNameFqn = getCurrentMethodNameFqn(1);
String currentFileName = getCurrentFileName(1);
return CurrentMethodNameFqn + "(" + currentFileName + ")";
}
public static String getInvokingMethodNameFqn()
{
return getInvokingMethodNameFqn(2);
}
private static String getInvokingMethodNameFqn(int offset)
{
String invokingClassName = getInvokingClassName(offset + 1);
String invokingMethodName = getInvokingMethodName(offset + 1);
return invokingClassName + "." + invokingMethodName;
}
public static String getInvokingFileNameFqn()
{
String invokingMethodNameFqn = getInvokingMethodNameFqn(2);
String invokingFileName = getInvokingFileName(2);
return invokingMethodNameFqn + "(" + invokingFileName + ")";
}
}যে পদ্ধতিটি বর্তমান পদ্ধতি বলে তার নাম পেতে আপনি ব্যবহার করতে পারেন:
new Exception("is not thrown").getStackTrace()[1].getMethodName()এটি আমার ম্যাকবুকের পাশাপাশি আমার অ্যান্ড্রয়েড ফোনেও কাজ করে
আমি চেষ্টাও করেছি:
Thread.currentThread().getStackTrace()[1]তবে অ্যান্ড্রয়েড "গেটস্ট্যাকট্রেস" ফিরিয়ে দেবে আমি এটিকে অ্যান্ড্রয়েডের সাথে এটি ঠিক করতে পারি
Thread.currentThread().getStackTrace()[2]তবে তারপরে আমি আমার ম্যাকবুকটিতে ভুল উত্তর পেয়েছি
getStackTrace()[0]চেয়ে বরং ব্যবহার করার জন্য আরও ভাল কাজ করেছে getStackTrace()[1]। YMMV।
Thread.currentThread().getStackTrace()[2]
Util.java:
public static String getCurrentClassAndMethodNames() {
final StackTraceElement e = Thread.currentThread().getStackTrace()[2];
final String s = e.getClassName();
return s.substring(s.lastIndexOf('.') + 1, s.length()) + "." + e.getMethodName();
}SomeClass.java:
public class SomeClass {
public static void main(String[] args) {
System.out.println(Util.getCurrentClassAndMethodNames()); // output: SomeClass.main
}
}final StackTraceElement e = Thread.currentThread().getStackTrace()[2]; কাজ করে; e.getClassName();পুরো শ্রেণীর নাম এবং e.getMethodName()মেথনের নামটি ফিরিয়ে দিন।
getStackTrace()[2]ভুল, এটি getStackTrace()[3]কারণ হতে হবে : [0] dalvik.s systemm.VMStack.getThreadStackTrace [1] java.lang.Thread.getStackTrace [2] Utils.getCurrentClassAndMethodNames [3] ফাংশন a () এটিকে ডাকে
এটি StackWalkerজাভা 9 থেকে ব্যবহার করে করা যেতে পারে ।
public static String getCurrentMethodName() {
return StackWalker.getInstance()
.walk(s -> s.skip(1).findFirst())
.get()
.getMethodName();
}
public static String getCallerMethodName() {
return StackWalker.getInstance()
.walk(s -> s.skip(2).findFirst())
.get()
.getMethodName();
}StackWalkerঅলস হওয়ার জন্য ডিজাইন করা হয়েছে, সুতরাং এটি বলার চেয়ে আরও দক্ষ হওয়ার সম্ভাবনা রয়েছে Thread.getStackTraceযা পুরো কলস্ট্যাকের জন্য আগ্রহের সাথে একটি অ্যারে তৈরি করে। আরও তথ্যের জন্য জেপ দেখুন।
একটি বিকল্প পদ্ধতি হ'ল একটি ব্যাতিক্রম তৈরি করা, তবে নিক্ষেপ করা নয়, এবং স্ট্যাক ট্রেস ডেটা পেতে যে বস্তুটি ব্যবহার করা উচিত তা যেহেতু ঘেরের পদ্ধতি সাধারণত সূচক 0-এ থাকবে - যতক্ষণ না জেভিএম সেই তথ্য সংরক্ষণ করে, অন্যদের মতো উপরোল্লিখিত. তবে এটি সস্তারতম পদ্ধতি নয়।
থ্রোয়েবল.জেটস্ট্যাকট্রেস () থেকে ( কমপক্ষে জাভা ৫ এর পর থেকে এটি একই রকম হয়েছে):
অ্যারের জিরোথ উপাদান (অ্যারের দৈর্ঘ্য অ-শূন্য হিসাবে ধরে নেওয়া) স্ট্যাকের শীর্ষকে উপস্থাপন করে যা ক্রমের সর্বশেষ পদ্ধতি আহ্বান। সাধারণত , এটি সেই বিন্দু যেখানে এই নিক্ষেপযোগ্য তৈরি এবং নিক্ষেপ করা হয়েছিল।
নীচের স্নিপেটটি অনুমান করে শ্রেণিটি স্থির নয় (কারণ getClass ()), তবে এটি একপাশে।
System.out.printf("Class %s.%s\n", getClass().getName(), new Exception("is not thrown").getStackTrace()[0].getMethodName());String methodName =Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println("methodName = " + methodName);আমি এটি ব্যবহার করে সমাধান পেয়েছি (অ্যান্ড্রয়েডে)
/**
* @param className fully qualified className
* <br/>
* <code>YourClassName.class.getName();</code>
* <br/><br/>
* @param classSimpleName simpleClassName
* <br/>
* <code>YourClassName.class.getSimpleName();</code>
* <br/><br/>
*/
public static void getStackTrace(final String className, final String classSimpleName) {
final StackTraceElement[] steArray = Thread.currentThread().getStackTrace();
int index = 0;
for (StackTraceElement ste : steArray) {
if (ste.getClassName().equals(className)) {
break;
}
index++;
}
if (index >= steArray.length) {
// Little Hacky
Log.w(classSimpleName, Arrays.toString(new String[]{steArray[3].getMethodName(), String.valueOf(steArray[3].getLineNumber())}));
} else {
// Legitimate
Log.w(classSimpleName, Arrays.toString(new String[]{steArray[index].getMethodName(), String.valueOf(steArray[index].getLineNumber())}));
}
}আমি জানি না যে বর্তমানে সম্পাদিত পদ্ধতিটির নাম পাওয়ার পেছনের উদ্দেশ্য কী, তবে যদি এটি কেবল ডিবাগিংয়ের উদ্দেশ্যে হয় তবে "লগব্যাক" এর মতো ফ্রেমওয়ার্কগুলি এখানে সহায়তা করতে পারে। উদাহরণস্বরূপ, লগব্যাকে, আপনাকে যা করতে হবে তা হল আপনার লগিং কনফিগারেশনে "% M" প্যাটার্নটি ব্যবহার করা । তবে এটি সতর্কতার সাথে ব্যবহার করা উচিত কারণ এটি কর্মক্ষমতা হ্রাস করতে পারে।
আপনি যদি কোন নামটি জানতে চান এমন পদ্ধতিটি যদি একটি জুনিট পরীক্ষা পদ্ধতি হয় তবে আপনি জুনিট টেস্টনামের নিয়মটি ব্যবহার করতে পারেন: https://stackoverflow.com/a/1426730/3076107
এখানে বেশিরভাগ উত্তর ভুল বলে মনে হচ্ছে।
public static String getCurrentMethod() {
return getCurrentMethod(1);
}
public static String getCurrentMethod(int skip) {
return Thread.currentThread().getStackTrace()[1 + 1 + skip].getMethodName();
}উদাহরণ:
public static void main(String[] args) {
aaa();
}
public static void aaa() {
System.out.println("aaa -> " + getCurrentMethod( ) );
System.out.println("aaa -> " + getCurrentMethod(0) );
System.out.println("main -> " + getCurrentMethod(1) );
}আউটপুট:
aaa -> aaa
aaa -> aaa
main -> mainআমি ম্যাকলেমেঞ্জের উত্তরটি আবার লিখেছিলাম :
private static Method m;
static {
try {
m = Throwable.class.getDeclaredMethod(
"getStackTraceElement",
int.class
);
}
catch (final NoSuchMethodException e) {
throw new NoSuchMethodUncheckedException(e);
}
catch (final SecurityException e) {
throw new SecurityUncheckedException(e);
}
}
public static String getMethodName(int depth) {
StackTraceElement element;
final boolean accessible = m.isAccessible();
m.setAccessible(true);
try {
element = (StackTraceElement) m.invoke(new Throwable(), 1 + depth);
}
catch (final IllegalAccessException e) {
throw new IllegalAccessUncheckedException(e);
}
catch (final InvocationTargetException e) {
throw new InvocationTargetUncheckedException(e);
}
finally {
m.setAccessible(accessible);
}
return element.getMethodName();
}
public static String getMethodName() {
return getMethodName(1);
}
MethodHandles.lookup().lookupClass().getEnclosingMethod().getName();getEnclosingMethod()NullPointerExceptionজাভা
এই পদ্ধতির সাথে কী দোষ রয়েছে:
class Example {
FileOutputStream fileOutputStream;
public Example() {
//System.out.println("Example.Example()");
debug("Example.Example()",false); // toggle
try {
fileOutputStream = new FileOutputStream("debug.txt");
} catch (Exception exception) {
debug(exception + Calendar.getInstance().getTime());
}
}
private boolean was911AnInsideJob() {
System.out.println("Example.was911AnInsideJob()");
return true;
}
public boolean shouldGWBushBeImpeached(){
System.out.println("Example.shouldGWBushBeImpeached()");
return true;
}
public void setPunishment(int yearsInJail){
debug("Server.setPunishment(int yearsInJail=" + yearsInJail + ")",true);
}
}এবং লোকেরা System.out.println(...)আপনাকে সর্বদা ব্যবহার করার জন্য উন্মাদ হওয়ার আগে , এবং এমন একটি পদ্ধতি তৈরি করতে পারে যাতে আউটপুট পুনর্নির্দেশ করা যায়, যেমন:
private void debug (Object object) {
debug(object,true);
}
private void dedub(Object object, boolean debug) {
if (debug) {
System.out.println(object);
// you can also write to a file but make sure the output stream
// ISN'T opened every time debug(Object object) is called
fileOutputStream.write(object.toString().getBytes());
}
}