📐 ➕ 👨🏻‍⚖️ हम अधिकतम करने का प्रयास करते हैं: ओआरएम से बाइटकोड विश्लेषण तक 😸 🤧 ⛹️

जैसा कि आप जानते हैं, एक वास्तविक प्रोग्रामर को अपने जीवन में 3 चीजें करनी चाहिए: अपनी प्रोग्रामिंग भाषा बनाएं, अपना खुद का ऑपरेटिंग सिस्टम लिखें और अपना ओआरएम बनाएं। और अगर मैंने एक लंबे समय पहले भाषा लिखी थी (शायद मैं आपको कुछ और समय बताऊंगा), और ओएस अभी भी आगे है, तो मैं आपको ओआरएम के बारे में अभी बताना चाहता हूं। अधिक सटीक होने के लिए, यह ओआरएम के बारे में भी नहीं है, लेकिन एक छोटे, स्थानीय और, जैसा कि लग रहा था, पूरी तरह से सरल सुविधा के कार्यान्वयन के बारे में।

एक साथ हम अपनी नाजुकता और गलतता के बारे में जागरूकता की कड़वाहट का एक सरल समाधान खोजने की खुशी से सभी तरह से जाएंगे। एक विशेष रूप से सार्वजनिक एपीआई का उपयोग करने से लेकर गंदे हैक तक। "लगभग बिना प्रतिबिंब" से "बाइट-कोड दुभाषिया में घुटने तक गहरा।"

कौन परवाह करता है कि बाइटकोड का विश्लेषण कैसे किया जाता है, यह किन कठिनाइयों से भरा होता है, और अंत में आपको क्या आश्चर्यजनक परिणाम मिल सकता है, बिल्ली का स्वागत है।

सामग्री

1 - यह सब कैसे शुरू हुआ।
2-4 - बायटेकोड के रास्ते में।
5 - बाईटकोड कौन है।
6 - विश्लेषण ही। यह इस अध्याय के लिए था कि सब कुछ कल्पना की गई थी और यह बहुत हिम्मत में था।
7 - और क्या खत्म हो सकता है। सपने, सपने ...
आफ्टरवर्ड - आफ्टरवर्ड।

UPD: प्रकाशन के तुरंत बाद, 6-8 भाग खो गए (जिसके लिए सब कुछ शुरू किया गया था)। फिक्स्ड।

भाग एक समस्या

कल्पना कीजिए कि हमारे पास एक सरल योजना है। एक ग्राहक है, उसके कई खाते हैं। उनमें से एक डिफ़ॉल्ट है। इसके अलावा, एक ग्राहक के पास कई सिम कार्ड हो सकते हैं और प्रत्येक सिम कार्ड को स्पष्ट रूप से सेट किया जा सकता है, या एक डिफ़ॉल्ट ग्राहक का उपयोग किया जा सकता है।

यहां बताया गया है कि यह मॉडल हमारे कोड (गेटिंग गेटर्स / सेटर / कंस्ट्रक्टर / ...) में कैसे वर्णित है।

@JdbcEntity(table = "CLIENT") public class Client { @JdbcId private Long id; @JdbcColumn private String name; @JdbcJoinedObject(localColumn = "DEFAULTACCOUNT") private Account defaultAccount; } @JdbcEntity(table = "ACCOUNT") public class Account { @JdbcId private Long id; @JdbcColumn private Long balance; @JdbcJoinedObject(localColumn = "CLIENT") private Client client; } @JdbcEntity(table = "CARD") public class Card { @JdbcId private Long id; @JdbcColumn private String msisdn; @JdbcJoinedObject(localColumn = "ACCOUNT") private Account account; @JdbcJoinedObject(localColumn = "CLIENT") private Client client; }

ओआरएम में, हमारे पास भविष्यवाणियों की अनुपस्थिति के लिए एक आवश्यकता है (हमें इस विशेष वर्ग का एक उदाहरण बनाना होगा) और एक अनुरोध। तदनुसार, यहां बताया गया है कि नक्शा प्राप्त करने का प्रयास करते समय डेटाबेस को क्या भेजा जाता है।

 select CARD.id id, CARD.msisdn msisdn, ACCOUNT_2.id ACCOUNT_2_id, ACCOUNT_2.balance ACCOUNT_2_balance, CLIENT_3.id CLIENT_3_id, CLIENT_3.name CLIENT_3_name, CLIENT_1.id CLIENT_1_id, CLIENT_1.name CLIENT_1_name, ACCOUNT_4.id ACCOUNT_4_id, ACCOUNT_4.balance ACCOUNT_4_balance from CARD left outer join CLIENT CLIENT_1 on CARD.CLIENT = CLIENT_1.id left outer join ACCOUNT ACCOUNT_2 on CARD.ACCOUNT = ACCOUNT_2.id left outer join CLIENT CLIENT_3 on ACCOUNT_2.CLIENT = CLIENT_3.id left outer join ACCOUNT ACCOUNT_4 on CLIENT_1.DEFAULTACCOUNT = ACCOUNT_4.id;

Uups। ग्राहक और बिल की नकल की जाती है। सच है, अगर आप इसके बारे में सोचते हैं, तो यह समझ में आता है - आखिरकार, फ्रेमवर्क को पता नहीं है कि कार्ड क्लाइंट और कार्ड अकाउंट क्लाइंट एक ही क्लाइंट हैं। एक क्वेरी को सांख्यिकीय रूप से और केवल एक ही बनाने की आवश्यकता है (अनुरोध की विशिष्टता पर प्रतिबंध याद रखें?)।

वैसे, बिल्कुल उसी कारण से, यहाँ पर कोई Card.account.client.defaultAccount और Card.client.defaultAccount.client फ़ील्ड नहीं हैं। केवल हम जानते हैं कि client और client.defaultAccount.client हमेशा मेल खाते हैं। और ढांचा नहीं जानता, उसके लिए यह एक मनमाना लिंक है। और ऐसे मामलों में क्या करना बहुत स्पष्ट नहीं है। मुझे पता है 3 विकल्प:

व्याख्याओं में स्पष्ट रूप से आक्रमणकारियों का वर्णन करें।
पुनरावर्ती प्रश्न ( with recursive / connect by with recursive ) बनाएं।
स्कोर करने के लिए।

लगता है कि हमने कौन सा विकल्प चुना? यह सही है। नतीजतन, सभी पुनरावर्ती क्षेत्र अब बिल्कुल भी नहीं भरे हैं और हमेशा शून्य है।

लेकिन अगर आप बारीकी से देखते हैं, तो आप दोहराव के पीछे दूसरी समस्या देख सकते हैं, और यह बहुत बुरा है। हम क्या चाहते थे? कार्ड नंबर और संतुलन। आपको क्या मिला? 4 जोड़ और 10 कॉलम। और यह बात तेजी से बढ़ रही है! खैर यानी हमारे पास वास्तव में एक ऐसी स्थिति है जहां, पहले, सुंदरता और अखंडता के लिए, हम पूरी तरह से एनोटेशन पर मॉडल का वर्णन करते हैं, और फिर, 5 क्षेत्रों के लिए , 15 जोड़ और 150 कॉलम के लिए अनुरोध किया जाता है। और इस समय यह वास्तव में डरावना हो जाता है।

भाग दो एक काम लेकिन असुविधाजनक समाधान

एक सरल समाधान तुरंत भीख माँगता है। केवल उन स्पीकरों का उपयोग किया जाएगा जिन्हें खींचा जाना चाहिए! कहना आसान है। सबसे स्पष्ट विकल्प (अपने हाथों से चयन लिखने के लिए) हम तुरंत छोड़ देंगे। खैर, तब नहीं, हमने मॉडल का वर्णन किया ताकि इसका उपयोग न किया जाए। काफी समय पहले एक विशेष विधि बनाई गई थी - partialGet । यह, सरल get विपरीत, List<String> - भरे जाने वाले क्षेत्रों के नाम को स्वीकार करता है। ऐसा करने के लिए, आपको पहले तालिकाओं में उपनाम दर्ज करना होगा

 @JdbcJoinedObject(localColumn = "ACCOUNT", sqlTableAlias = "a") private Account account; @JdbcJoinedObject(localColumn = "CLIENT", sqlTableAlias = "c") private Client client;

और फिर परिणाम का आनंद लें।

 List<String> requiredColumns = asList("msisdn", "c_a_balance", "a_balance"); String query = cardMapper.getSelectSQL(requiredColumns, DatabaseType.ORACLE); System.out.println(query);

 select CARD.msisdn msisdn, c_a.balance c_a_balance, a.balance a_balance from CARD left outer join ACCOUNT a on CARD.ACCOUNT = a.id left outer join CLIENT c on CARD.CLIENT = c.id left outer join ACCOUNT c_a on c.DEFAULTACCOUNT = c_a.id;

और सब कुछ ठीक लगता है, लेकिन, वास्तव में, नहीं। यहां बताया गया है कि वास्तविक कोड में इसका उपयोग कैसे किया जाएगा।

 Card card = cardDAO.partialGet(cardId, "msisdn", "c_a_balance", "a_balance"); ... ... ...    ... ... ... long clientId = card.getClient().getId();//, NPE.  , id    ?!

और यह पता चला है कि आप अब केवल पार्टगेट का उपयोग कर सकते हैं यदि इसके बीच की दूरी और परिणाम का उपयोग केवल कुछ पंक्तियाँ हैं। लेकिन अगर परिणाम दूर जाता है या, भगवान न करे, किसी विधि के अंदर पारित किया जाता है, तो यह समझना पहले से ही बहुत मुश्किल है कि कौन से क्षेत्र भरे हुए हैं और कौन से नहीं हैं। इसके अलावा, अगर एनपीई कहीं हुआ, तो आपको अभी भी यह समझने की आवश्यकता है कि क्या यह वास्तव में अशक्त डेटाबेस से वापस आ गया है, या क्या हमने अभी इस क्षेत्र को नहीं भरा है। सब सब में, बहुत अविश्वसनीय।

आप निस्संदेह, केवल विशेष रूप से अनुरोध के लिए अपनी मैपिंग के साथ एक अन्य ऑब्जेक्ट लिख सकते हैं, या यहां तक कि पूरी तरह से अपने हाथों से पूरी तरह से चुन सकते हैं और इसे कुछ Tuple में इकट्ठा कर सकते हैं। दरअसल, वास्तव में अब ज्यादातर जगहों पर हम ऐसा ही करते हैं। लेकिन फिर भी मैं अपने हाथों से चयन नहीं लिखना चाहूंगा, न कि नकल की नकल करना।

भाग तीन एक सुविधाजनक लेकिन निष्क्रिय समाधान।

यदि आप थोड़ा और सोचते हैं, तो बहुत जल्दी जवाब मेरे दिमाग में आता है - आपको इंटरफेस का उपयोग करने की आवश्यकता है। फिर बस घोषणा करते हैं

 public interface MsisdnAndBalance { String getMsisdn(); long getBalance(); }

और उपयोग करें

 MsisdnAndBalance card = cardDAO.partialGet(cardId, ...);

और वह सब है। कुछ भी अतिरिक्त मत कहो। इसके अलावा, कोटलिन / दस / गर्भ के संक्रमण के साथ, यहां तक कि इस भयानक प्रकार को भी समाप्त किया जा सकता है। लेकिन यहां सबसे महत्वपूर्ण बिंदु अभी भी छोड़ा गया है। partialGet को क्या तर्क दिए जाने चाहिए? थोंग्स, पहले की तरह, अब और महसूस नहीं करते, क्योंकि गलतियाँ करने और गलत क्षेत्र लिखने के लिए जोखिम बहुत अच्छा है। और मैं चाहता हूं कि आप किसी तरह सक्षम हों

 MsisdnAndBalance card = cardDAO.partialGet(cardId, MsisdnAndBalance.class);

या संशोधित जेनरिक के माध्यम से कोटलिन पर भी बेहतर

 val card = cardDAO.paritalGet<MsisdnAndBalance>(cardId)

एह, एक विस्फोट। दरअसल, आगे की पूरी कहानी इस विकल्प के क्रियान्वयन की है।

भाग चार बाईटेकोड के रास्ते में

मुख्य समस्या यह है कि तरीके इंटरफ़ेस से आते हैं, और एनोटेशन फ़ील्ड के ऊपर हैं। और हमें इन्हीं क्षेत्रों को विधियों द्वारा खोजने की आवश्यकता है। पहला और सबसे स्पष्ट विचार मानक जावा बीन सम्मेलन का उपयोग करना है। और तुच्छ गुणों के लिए, यह भी काम करता है। लेकिन यह बहुत अस्थिर है। उदाहरण के लिए, यह एक इंटरफ़ेस में एक विधि का नाम बदलने के लायक है (वैचारिक रिफैक्टिंग के माध्यम से), क्योंकि सब कुछ तुरंत अलग हो जाता है। कार्यान्वयन कक्षाओं में तरीकों का नाम बदलने के लिए विचार काफी स्मार्ट है, लेकिन यह समझने के लिए पर्याप्त नहीं है कि यह एक गटर था और आपको फ़ील्ड का नाम बदलने की आवश्यकता है। और इसी तरह के समाधान से खेतों का दोहराव होता है। उदाहरण के लिए, अगर मुझे अपने इंटरफ़ेस में getClientId() विधि की आवश्यकता है, तो मैं इसे केवल सही तरीके से लागू नहीं कर सकता

 public class Client implements HasClientId { private Long id; @Override public Long getClientId() { return id; } }

 public class Card implements HasClientId { private Client client; @Override public Long getClientId() { return client.getId(); } }

और मुझे खेतों की नकल करनी है। और Client में दोनों id और clientId खींचें, और क्लाइंट के बगल वाले मैप में स्पष्ट रूप से clientId । और सुनिश्चित करें कि यह सब नहीं छोड़ता है। इसके अलावा, मुझे काम करने के लिए गैर-तुच्छ तर्क के साथ गेटर्स भी चाहिए, उदाहरण के लिए

 public class Card implements HasBalance { private Account account; private Client client; public long getBalance() { if (account != null) return account.getBalance(); else return client.getDefaultAccount().getBalance(); } }

तो नाम से खोज करने के विकल्प की अब आवश्यकता नहीं है, आपको कुछ अधिक मुश्किल है।

अगला विकल्प पूरी तरह से पागल था और मेरे सिर में लंबे समय तक नहीं रहा, लेकिन कहानी की पूर्णता के लिए मैं इसका भी वर्णन करूंगा। पार्सिंग स्टेज पर, हम एक खाली इकाई बना सकते हैं और बस खेतों में कुछ मान लिखते हुए मुड़ जाते हैं, और उसके बाद हमें गेटर्स मिलते हैं और देखते हैं कि यह बदल गया है या नहीं। इसलिए हम देखेंगे कि name फ़ील्ड में रिकॉर्ड से getClientId का मान नहीं बदलता है, लेकिन रिकॉर्ड id बदल जाता है। इसके अलावा, स्थिति जब विभिन्न प्रकार के isActive() = i_active != 0 और फ़ील्ड (जैसे कि isActive() = i_active != 0 ) निश्चित रूप से यहां हैं। लेकिन कम से कम तीन गंभीर समस्याएं हैं (शायद अधिक है, लेकिन मैंने आगे नहीं सोचा है)।

इस एल्गोरिथ्म के साथ सार के लिए स्पष्ट आवश्यकता यह है कि यदि "संबंधित" फ़ील्ड नहीं बदला गया है, तो गेट्टर से "उसी" मूल्य को वापस करना होगा। "एक समान" - हमने जो तुलना ऑपरेटर चुना है, उसके दृष्टिकोण से। == यह स्पष्ट रूप से नहीं हो सकता है (अन्यथा कुछ getAsInt() = Integer.parseInt(strField)) काम करना बंद कर देगा getAsInt() = Integer.parseInt(strField)) । बराबरी पर रहता है। इसलिए, अगर गेट्टर प्रत्येक कॉल पर फ़ील्ड्स द्वारा उत्पन्न किसी प्रकार की उपयोगकर्ता इकाई लौटाता है, तो उसके पास equals ओवरराइड होना चाहिए।
संपीड़न मैपिंग। उदाहरण के लिए int -> boolean ऊपर के साथ। यदि हम 0 और 1 के मूल्यों पर जाँच करते हैं, तो हम एक बदलाव देखेंगे। लेकिन अगर ४० और ४२ पर हैं, तो दोनों बार हम सच हो जाते हैं।
गेटर्स में जटिल कन्वर्टर्स हो सकते हैं जो खेतों में कुछ अपरिवर्तनों पर भरोसा करते हैं (उदाहरण के लिए, एक विशेष स्ट्रिंग प्रारूप)। और हमारे उत्पन्न आंकड़ों पर वे अपवादों को फेंक देंगे।

तो सामान्य तौर पर, विकल्प भी काम नहीं कर रहा है।

पूरी बात पर चर्चा करने की प्रक्रिया में, मैंने शुरू में मजाक में "अच्छी तरह से, नफीग वाक्यांश कहा, यह बाईटेकोड को देखना आसान है, सब कुछ वहां लिखा है।" उस समय, मुझे यह भी एहसास नहीं था कि यह विचार मुझे निगल जाएगा, और सब कुछ कितना दूर चला जाएगा।

भाग पांच बाइटेकोड क्या है और यह कैसे काम करता है

new #4, dup, invokespecial #5, areturn
यदि आप समझते हैं कि यहाँ क्या लिखा गया है और यह कोड क्या करता है, तो आप अगले भाग को छोड़ सकते हैं।

अस्वीकरण 1. दुर्भाग्य से, आगे की कहानी को समझने के लिए, आपको कम से कम एक बुनियादी समझ की आवश्यकता है कि जावा बायटेकोड कैसा दिखता है, इसलिए मैं इसके बारे में कुछ पैराग्राफ लिखूंगा। किसी भी तरह से पूरा होने का नाटक नहीं।

अस्वीकरण 2. यह विशेष रूप से विधियों के शरीर के बारे में होगा। न तो निरंतर पूल के बारे में, न ही पूरी तरह से कक्षा की संरचना के बारे में, और न ही खुद की घोषणाओं के बारे में, मैं एक शब्द भी कहूंगा।

मुख्य चीज जिसे आपको बायटेकोड के बारे में समझना होगा, वह जावा स्टैक वर्चुअल मशीन के लिए कोडांतरक है। इसका मतलब है कि निर्देशों के लिए तर्क स्टैक से लिए गए हैं और निर्देशों से रिटर्न मान स्टैक पर वापस धकेल दिए गए हैं। इस दृष्टि से, हम यह कह सकते हैं कि बाईटकोड रिवर्स पोलिश अंकन में लिखा गया है । स्टैक के अलावा, विधि में स्थानीय चर की एक सरणी भी है। विधि में प्रवेश करने पर, this पद्धति के सभी तर्कों को इसमें लिखा जाता है, और निष्पादन के दौरान स्थानीय चर जमा हो जाते हैं। यहाँ एक सरल उदाहरण है।

 public class Foo { private int bar; public int updateAndReturn(long baz, String str) { int result = (int) baz; result += str.length(); bar = result; return result; } }

मैं प्रारूप में टिप्पणी लिखूंगा

 # [(<local_variable_index>:<actual_value>)*], [(<value_on_stack>)*]

बाईं ओर ढेर के ऊपर।

 public int updateAndReturn(long, java.lang.String); Code: # [0:this, 1:long baz, 3:str], () 0: lload_1 # [0:this, 1:long baz, 3:str], (long baz) 1: l2i # [0:this, 1:long baz, 3:str], (int baz) 2: istore 4 # [0:this, 1:long baz, 3:str, 4:int baz], () 4: iload 4 # [0:this, 1:long baz, 3:str, 4:int baz], (int baz) 6: aload_3 # [0:this, 1:long baz, 3:str, 4:int baz], (str, int baz) 7: invokevirtual #2 // Method java/lang/String.length:()I # [0:this, 1:long baz, 3:str, 4:int baz], (length(str), int baz) 10: iadd # [0:this, 1:long baz, 3:str, 4:int baz], (length(str) + int baz) 11: istore 4 # [0:this, 1:long baz, 3:str, 4:length(str) + int baz], () 13: aload_0 # [0:this, 1:long baz, 3:str, 4:length(str) + int baz], (this) 14: iload 4 # [0:this, 1:long baz, 3:str, 4:length(str) + int baz], (length(str) + int baz, this) 16: putfield #3 // Field bar:I # [0:this, 1:long baz, 3:str, 4:length(str) + int baz], (),     bar 19: iload 4 # [0:this, 1:long baz, 3:str, 4:length(str) + int baz], (length(str) + int baz) 21: ireturn #  int   ,

बहुत सारे निर्देश हैं। पूरी सूची को JVMS के छठे अध्याय में देखने की आवश्यकता है , विकिपीडिया पर एक संक्षिप्त रिटेलिंग है । बड़ी संख्या में निर्देश विभिन्न प्रकारों के लिए एक दूसरे की नकल करते हैं (उदाहरण के लिए, int के लिए lload और लंबे समय के लिए lload )। इसके अलावा, पहले 4 स्थानीय चरों के साथ काम करने के लिए, उनके निर्देशों पर प्रकाश डाला गया है (उदाहरण के लिए, उदाहरण के लिए, वहाँ lload_1 और यह तर्क को बिल्कुल स्वीकार नहीं करता है, लेकिन सिर्फ lload । यह एक तर्क के रूप में स्थानीय चर की संख्या ले जाएगा। ऊपर के उदाहरण में, एक समान iload )।

विश्व स्तर पर, हम निर्देशों के निम्नलिखित समूहों में रुचि लेंगे:

*load* , *store* - एक स्थानीय चर को पढ़ें / लिखें
इंडेक्स द्वारा एक *aload , *aload - पढ़ें / लिखें
getfield , putfield - read / write field
getstatic , putstatic - स्टैटिक फील्ड को पढ़ें / लिखें
checkcast - ऑब्जेक्ट प्रकारों के बीच कास्ट। जरूरत है क्योंकि टाइप किए गए मान स्टैक पर और स्थानीय चर में होते हैं। उदाहरण के लिए, ऊपर कलाकारों की लंबी अवधि के लिए l2i था -> int।
invoke* - विधि कॉल
*return - मान लौटाएं और विधि से बाहर निकलें

भाग छः मुख्य

उन लोगों के लिए जो इस तरह के लंबे परिचय से चूक गए, साथ ही साथ पुस्तकालय के संदर्भ में मूल समस्या और कारण से ध्यान हटाने के लिए, हम समस्या को और अधिक सटीक रूप से तैयार करते हैं।

यह आवश्यक है, हाथ पर एक java.lang.reflect.Method उदाहरण होने के लिए, सभी गैर-स्थिर क्षेत्रों (दोनों वर्तमान और सभी नेस्टेड ऑब्जेक्ट) की सूची प्राप्त करने के लिए जिनके रीडिंग (सीधे या ट्रांसेटिव) इस पद्धति के अंदर होंगे।

उदाहरण के लिए, ऐसी विधि के लिए

 public long getBalance() { Account acc; if (account != null) acc = account; else acc = client.getDefaultAccount(); return acc.getBalance(); }

आपको दो फ़ील्ड्स की एक सूची प्राप्त करने की आवश्यकता है: account.balance । client.defaultAccount.balance और client.defaultAccount.balance ।

मैं लिखूंगा, यदि संभव हो तो, एक सामान्यीकृत समाधान। लेकिन एक-दो स्थानों पर आपको सामान्य समस्या, समस्याओं के समाधान के लिए मूल समस्या के ज्ञान का उपयोग करना होगा।

सबसे पहले आपको विधि निकाय का बायटेककोड स्वयं प्राप्त करना होगा, लेकिन आप सीधे जावा के माध्यम से ऐसा नहीं कर सकते। लेकिन कब से चूंकि विधि मूल रूप से कुछ वर्ग के अंदर मौजूद है, इसलिए स्वयं कक्षा प्राप्त करना आसान है। विश्व स्तर पर, मुझे दो विकल्प पता हैं: क्लास लोडिंग प्रक्रिया में वेज और पहले से पढ़ी हुई byte[] इंटरसेप्ट करता है, या डिस्क पर ClassName.class फाइल ClassName.class और इसे पढ़ता है। सामान्य पुस्तकालय के स्तर पर लोडिंग का अवरोधन नहीं किया जा सकता है। आपको या तो jagagent कनेक्ट करने या कस्टम क्लासलॉडर का उपयोग करने की आवश्यकता है। किसी भी स्थिति में, jvm / एप्लिकेशन को कॉन्फ़िगर करने के लिए अतिरिक्त चरणों की आवश्यकता होती है, और यह असुविधाजनक है। आप इसे आसान कर सकते हैं। सभी "साधारण" कक्षाएं हमेशा एक्सटेंशन ".class" के साथ एक ही फ़ाइल में होती हैं, जिस पथ के लिए क्लास पैकेज है। हां, यह कुछ कस्टम क्लास लोडर द्वारा लोड किए गए गतिशील रूप से जोड़े गए वर्गों या कक्षाओं को खोजने के लिए काम नहीं करेगा, लेकिन हमें jdbc मॉडल के लिए इसकी आवश्यकता है, इसलिए हम विश्वास के साथ कह सकते हैं कि सभी वर्गों को "डिफ़ॉल्ट तरीके से" जार में पैक किया जाएगा। कुल:

 private static InputStream getClassFile(Class<?> clazz) { String file = clazz.getName().replace('.', '/') + ".class"; ClassLoader cl = clazz.getClassLoader(); if (cl == null) return ClassLoader.getSystemResourceAsStream(file); else return cl.getResourceAsStream(file); }

हुर्रे, बाइट सरणी पढ़ें। हम इसके साथ आगे क्या करेंगे? सिद्धांत रूप में, बाइटकोड को पढ़ने / लिखने के लिए जावा में कई पुस्तकालय हैं, लेकिन एएसएम का उपयोग आमतौर पर सबसे निचले स्तर के काम के लिए किया जाता है। क्योंकि यह उच्च प्रदर्शन और ऑन-द-फ्लाई ऑपरेशन के लिए तेज किया जाता है, विज़िटर एपीआई वहां मुख्य है - एसएसएम क्रमिक रूप से कक्षा को पढ़ता है और उचित तरीकों को खींचता है

 public abstract class ClassVisitor { public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {...} public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {...} public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {...} ... } public abstract class MethodVisitor { protected MethodVisitor mv; public MethodVisitor(final int api, final MethodVisitor mv) { ... this.mv = mv; } public void visitJumpInsn(int opcode, Label label) { if (mv != null) { mv.visitJumpInsn(opcode, label); } } ... }

उपयोगकर्ता को उसके हित के तरीकों को फिर से परिभाषित करने और अपने स्वयं के विश्लेषण / परिवर्तन तर्क को लिखने के लिए आमंत्रित किया जाता है। MethodVisitor के उदाहरण पर अलग से, मैं इस तथ्य पर ध्यान आकर्षित करना चाहूंगा कि सभी आगंतुकों का प्रतिनिधिमंडल के माध्यम से डिफ़ॉल्ट कार्यान्वयन है।

मुख्य एपीआई के अलावा, बॉक्स के बाहर एक ट्री एपीआई भी है। यदि कोर एपीआई एसएएक्स पार्सर का एक एनालॉग है, तो ट्री एपीआई डोम का एक एनालॉग है। हमें एक ऐसी वस्तु मिलती है जिसके अंदर वर्ग / विधि के बारे में सभी जानकारी संग्रहीत होती है और हम इसका विश्लेषण कर सकते हैं जैसा कि हम किसी भी स्थान पर छलांग के साथ चाहते हैं। वास्तव में, यह एपीआई एक *Visitor कार्यान्वयन है जो visit* अंदर visit* तरीके बस जानकारी संग्रहीत करता है। लगभग सभी तरीके इस तरह दिखते हैं:

 public class MethodNode extends MethodVisitor { @Override public void visitJumpInsn(final int opcode, final Label label) { instructions.add(new JumpInsnNode(opcode, getLabelNode(label))); } ... }

अब हम अंत में विश्लेषण के लिए विधि लोड कर सकते हैं।

 private static class AnalyzerClassVisitor extends ClassVisitor { private final String getterName; private final String getterDesc; private MethodNode methodNode; public AnalyzerClassVisitor(Method getter) { super(ASM6); this.getterName = getter.getName(); this.getterDesc = getMethodDescriptor(getter); } public MethodNode getMethodNode() { if (methodNode == null) throw new IllegalStateException(); return methodNode; } @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { //      if (!name.equals(getterName) || !desc.equals(getterDesc)) return null; return new AnalyzerMethodVisitor(access, name, desc, signature, exceptions); } private class AnalyzerMethodVisitor extends MethodVisitor { public AnalyzerMethodVisitor(int access, String name, String desc, String signature, String[] exceptions) { super(ASM6, new MethodNode(ASM6, access, name, desc, signature, exceptions)); } @Override public void visitEnd() { //     ,     MethodVisitor    if (methodNode != null) throw new IllegalStateException(); methodNode = (MethodNode) mv; } } }

पूर्ण कोड पढ़ने की विधि।

MethodNode सीधे नहीं लौटाया जाता है, बल्कि एक्स की एक जोड़ी के साथ एक आवरण। खेतों क्योंकि हमें बाद में भी उनकी आवश्यकता होगी। प्रविष्टि बिंदु (और केवल सार्वजनिक विधि) readMethod(Method): MethodInfo ।

 public class MethodReader { public static class MethodInfo { private final String internalDeclaringClassName; private final int classAccess; private final MethodNode methodNode; public MethodInfo(String internalDeclaringClassName, int classAccess, MethodNode methodNode) { this.internalDeclaringClassName = internalDeclaringClassName; this.classAccess = classAccess; this.methodNode = methodNode; } public String getInternalDeclaringClassName() { return internalDeclaringClassName; } public int getClassAccess() { return classAccess; } public MethodNode getMethodNode() { return methodNode; } } public static MethodInfo readMethod(Method method) { Class<?> clazz = method.getDeclaringClass(); String internalClassName = getInternalName(clazz); try (InputStream is = getClassFile(clazz)) { ClassReader cr = new ClassReader(is); AnalyzerClassVisitor cv = new AnalyzerClassVisitor(internalClassName, method); cr.accept(cv, SKIP_DEBUG | SKIP_FRAMES); return new MethodInfo(internalClassName, cv.getAccess(), cv.getMethodNode()); } catch (IOException e) { throw new RuntimeException(e); } } private static InputStream getClassFile(Class<?> clazz) { String file = clazz.getName().replace('.', '/') + ".class"; ClassLoader cl = clazz.getClassLoader(); if (cl == null) return ClassLoader.getSystemResourceAsStream(file); else return cl.getResourceAsStream(file); } private static class AnalyzerClassVisitor extends ClassVisitor { private final String className; private final String getterName; private final String getterDesc; private MethodNode methodNode; private int access; public AnalyzerClassVisitor(String internalClassName, Method getter) { super(ASM6); this.className = internalClassName; this.getterName = getter.getName(); this.getterDesc = getMethodDescriptor(getter); } public MethodNode getMethodNode() { if (methodNode == null) throw new IllegalStateException(); return methodNode; } public int getAccess() { return access; } @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { if (!name.equals(className)) throw new IllegalStateException(); this.access = access; } @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { if (!name.equals(getterName) || !desc.equals(getterDesc)) return null; return new AnalyzerMethodVisitor(access, name, desc, signature, exceptions); } private class AnalyzerMethodVisitor extends MethodVisitor { public AnalyzerMethodVisitor(int access, String name, String desc, String signature, String[] exceptions) { super(ASM6, new MethodNode(ASM6, access, name, desc, signature, exceptions)); } @Override public void visitEnd() { if (methodNode != null) throw new IllegalStateException(); methodNode = (MethodNode) mv; } } } }

यह सीधे विश्लेषण करने का समय है। इसे कैसे बनाया जाए? पहला विचार सभी getfield निर्देशों को देखना है। प्रत्येक getfield कहती है कि यह कौन सा फील्ड है और कौन सा क्लास है। इसे हमारी कक्षा के उन सभी क्षेत्रों के लिए आवश्यक माना जा सकता है जहां तक पहुंच थी। लेकिन, दुर्भाग्य से, यह काम नहीं करता है। यहां पहली समस्या यह है कि अतिरिक्त पर कब्जा किया जा रहा है।

 class Foo { private int bar; private int baz; public int test() { return bar + new Foo().baz; } }

इस एल्गोरिथ्म के साथ, हम मानते हैं कि बाज मैदान की जरूरत है, हालांकि, वास्तव में, नहीं। लेकिन फिर भी यह समस्या बनी रह सकती है। लेकिन तरीकों के साथ क्या करना है?

 public class Client implements HasClientId { private Long id; public Long getId() { HasClientId obj = this; return obj.getClientId(); } @Override public Long getClientId() { return id; } }

यदि हम उसी तरीके से कॉल करते हैं जैसे हम फ़ील्ड पढ़ने के लिए देखते हैं, तो हमें getClientId नहीं मिलेगा। इसके लिए Client.getClientId कोई कॉल नहीं है, लेकिन केवल HasClientId.getClientId कॉल करें। बेशक, आप वर्तमान कक्षा के सभी तरीकों पर विचार कर सकते हैं, इसके सभी सुपरक्लासेस और सभी इंटरफेस का उपयोग किया जा सकता है, लेकिन यह पहले से ही बहुत अधिक है। तो आप गलती से toString पर कब्जा कर सकते हैं, और इसमें सामान्य रूप से सभी क्षेत्रों की एक सूची है।

इसके अलावा, हम नेस्टेड ऑब्जेक्ट पर भी काम करने के लिए गेट्टर कॉल चाहते हैं

 public class Account { private Client client; public long getClientId() { return client.getId(); } }

और यहाँ पर Client.getId मेथड पर कॉल Account क्लास के लिए बिलकुल भी लागू नहीं होता है।

एक मजबूत इच्छा के साथ, आप अभी भी कुछ समय के लिए विशेष मामलों के लिए हैक के बारे में सोच सकते हैं, लेकिन बहुत जल्दी यह समझ में आता है कि "चीजें इस तरह से नहीं की जाती हैं" और आपको निष्पादन और डेटा आंदोलन के प्रवाह की पूरी तरह से निगरानी करने की आवश्यकता है। getfield , this , - this . यहाँ एक उदाहरण है:

 class Client { public long id; } class Account { public long id; public Client client; public long test() { return client.id + new Account().id; } }

 class Account { public Client client; public long test(); Code: 0: aload_0 1: getfield #2 // Field client:LClient; 4: getfield #3 // Field Client.id:J 7: new #4 // class Account 10: dup 11: invokespecial #5 // Method "<init>":()V 14: getfield #6 // Field id:J 17: ladd 18: lreturn }

1: getfield this , aload_0 .
4: getfield — , 1: getfield , , , this .
14: getfield . क्योंकि , ( Account ), this , , 7: new .

, Account.client.id , Account.id — . , , .

— , , aload_0 getfield this , , . , . . — ! -, . MethodNode , ( ). , .. (//) .

 public class Analyzer<V extends Value> { public Analyzer(final Interpreter<V> interpreter) {...} public Frame<V>[] analyze(final String owner, final MethodNode m) {...} }

Analyzer ( Frame , ) . , , , , //etc.

 public abstract class Interpreter<V extends Value> { public abstract V newValue(Type type); public abstract V newOperation(AbstractInsnNode insn) throws AnalyzerException; public abstract V copyOperation(AbstractInsnNode insn, V value) throws AnalyzerException; public abstract V unaryOperation(AbstractInsnNode insn, V value) throws AnalyzerException; public abstract V binaryOperation(AbstractInsnNode insn, V value1, V value2) throws AnalyzerException; public abstract V ternaryOperation(AbstractInsnNode insn, V value1, V value2, V value3) throws AnalyzerException; public abstract V naryOperation(AbstractInsnNode insn, List<? extends V> values) throws AnalyzerException; public abstract void returnOperation(AbstractInsnNode insn, V value, V expected) throws AnalyzerException; public abstract V merge(V v, V w); }

V — , , . Analyzer , , , . , getfield — , , . , unaryOperation(AbstractInsnNode insn, V value): V , . 1: getfield Value , " client , Client ", 14: getfield " — - , ".

merge(V v, V w): V . , , . उदाहरण के लिए:

 public long getBalance() { Account acc; if (account != null) acc = account; else acc = client.getDefaultAccount(); return acc.getBalance(); }

Account.getBalance() . - . . ? merge .

— SuperInterpreter extends Interpreter<SuperValue> ? यह सही है। SuperValue . — , . , .

 public class Value extends BasicValue { private final Set<Ref> refs; private Value(Type type, Set<Ref> refs) { super(type); this.refs = refs; } } public class Ref { private final List<Field> path; private final boolean composite; public Ref(List<Field> path, boolean composite) { this.path = path; this.composite = composite; } }

composite . , . , String . String.length() , , name , name.value.length . , length — , , arraylength . ? नहीं! — . , , , . , Date , String , Long , . , , .

 class Persion { @JdbcColumn(converter = CustomJsonConverter.class) private PassportInfo passportInfo; }

PassportInfo . , . , composite . .

 public class Ref { private final List<Field> path; private final boolean composite; public Ref(List<Field> path, boolean composite) { this.path = path; this.composite = composite; } public List<Field> getPath() { return path; } public boolean isComposite() { return composite; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Ref ref = (Ref) o; return Objects.equals(path, ref.path); } @Override public int hashCode() { return Objects.hash(path); } @Override public String toString() { if (path.isEmpty()) return "<[this]>"; else return "<" + path.stream().map(Field::getName).collect(joining(".")) + ">"; } public static Ref thisRef() { return new Ref(emptyList(), true); } public static Optional<Ref> childRef(Ref parent, Field field, Configuration configuration) { if (!parent.isComposite()) return empty(); if (parent.path.contains(field))//    ,   return empty(); List<Field> path = new ArrayList<>(parent.path); path.add(field); return of(new Ref(path, configuration.isCompositeField(field))); } public static Optional<Ref> childRef(Ref parent, Ref child) { if (!parent.isComposite()) return empty(); if (child.path.stream().anyMatch(parent.path::contains))// ,   return empty(); List<Field> path = new ArrayList<>(parent.path); path.addAll(child.path); return of(new Ref(path, child.composite)); } }

 public class Value extends BasicValue { private final Set<Ref> refs; private Value(Type type, Set<Ref> refs) { super(type); this.refs = refs; } public Set<Ref> getRefs() { return refs; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; if (!super.equals(o)) return false; Value value = (Value) o; return Objects.equals(refs, value.refs); } @Override public int hashCode() { return Objects.hash(super.hashCode(), refs); } @Override public String toString() { return "(" + refs.stream().map(Object::toString).collect(joining(",")) + ")"; } public static Value typedValue(Type type, Ref ref) { return new Value(type, singleton(ref)); } public static Optional<Value> childValue(Value parent, Value child) { Type type = child.getType(); Set<Ref> fields = parent.refs.stream() .flatMap(p -> child.refs.stream().map(c -> childRef(p, c))) .filter(Optional::isPresent) .map(Optional::get) .collect(toSet()); if (fields.isEmpty()) return empty(); return of(new Value(type, fields)); } public static Optional<Value> childValue(Value parent, FieldInsnNode childInsn, Configuration configuration) { Type type = Type.getType(childInsn.desc); Field child = resolveField(childInsn); Set<Ref> fields = parent.refs.stream() .map(p -> childRef(p, child, configuration)) .filter(Optional::isPresent) .map(Optional::get) .collect(toSet()); if (fields.isEmpty()) return empty(); return of(new Value(type, fields)); } public static Value mergeValues(Collection<Value> values) { List<Type> types = values.stream().map(BasicValue::getType).distinct().collect(toList()); if (types.size() != 1) { String typesAsString = types.stream().map(Type::toString).collect(joining(", ", "(", ")")); throw new IllegalStateException("could not merge " + typesAsString); } Set<Ref> fields = values.stream().flatMap(v -> v.refs.stream()).distinct().collect(toSet()); return new Value(types.get(0), fields); } public static boolean isComposite(BasicValue value) { return value instanceof Value && value.getType().getSort() == Type.OBJECT && ((Value) value).refs.stream().anyMatch(Ref::isComposite); } }

, . चलो चलते हैं!

 public class FieldsInterpreter extends BasicInterpreter {

, BasicInterpreter . BasicValue ( , Value extends BasicValue ) .

 public class BasicValue implements Value { public static final BasicValue UNINITIALIZED_VALUE = new BasicValue(null); public static final BasicValue INT_VALUE = new BasicValue(Type.INT_TYPE); public static final BasicValue FLOAT_VALUE = new BasicValue(Type.FLOAT_TYPE); public static final BasicValue LONG_VALUE = new BasicValue(Type.LONG_TYPE); public static final BasicValue DOUBLE_VALUE = new BasicValue(Type.DOUBLE_TYPE); public static final BasicValue REFERENCE_VALUE = new BasicValue(Type.getObjectType("java/lang/Object")); public static final BasicValue RETURNADDRESS_VALUE = new BasicValue(Type.VOID_TYPE); private final Type type; public BasicValue(final Type type) { this.type = type; } }

( (Value)basicValue ) , , ( " iconst ") .

newValue . , , " ". , this catch . , , . BasicInterpreter BasicValue(actualType) BasicValue.REFERENCE_VALUE . .

 @Override public BasicValue newValue(Type type) { if (type != null && type.getSort() == OBJECT) return new BasicValue(type); return super.newValue(type); }

entry point. this . , - , , this , BasicValue(actualType) , Value.typedValue(actualType, Ref.thisRef()) . , , this newValue , . , .. , this . this . , . , this 0. , . , , . .

 @Override public BasicValue copyOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { if (wasUpdated || insn.getType() != VAR_INSN || ((VarInsnNode) insn).var != 0) { return super.copyOperation(insn, value); } switch (insn.getOpcode()) { case ALOAD: return typedValue(value.getType(), thisRef()); case ISTORE: case LSTORE: case FSTORE: case DSTORE: case ASTORE: wasUpdated = true; } return super.copyOperation(insn, value); }

. . , , , — , . , .

 @Override public BasicValue merge(BasicValue v, BasicValue w) { if (v.equals(w)) return v; if (v instanceof Value || w instanceof Value) { if (!Objects.equals(v.getType(), w.getType())) { if (v == UNINITIALIZED_VALUE || w == UNINITIALIZED_VALUE) return UNINITIALIZED_VALUE; throw new IllegalStateException("could not merge " + v + " and " + w); } if (v instanceof Value != w instanceof Value) { if (v instanceof Value) return v; else return w; } return mergeValues(asList((Value) v, (Value) w)); } return super.merge(v, w); }

. ""? ? वास्तव में नहीं। . , .. . , 3 ( ): putfield , putstatic , aastore . . putstatic ( ) . , . putfield aastore . , , . ( ) . , . , — .

 public class Account { private Client client; public Long getClientId() { return Optional.ofNullable(client).map(Client::getId).orElse(null); } }

, ( ofNullable Optional client value ), . . . , - ofNullable(client) , - map(Client::getId) , .

putfield , putstatic aastore .

 @Override public BasicValue binaryOperation(AbstractInsnNode insn, BasicValue value1, BasicValue value2) throws AnalyzerException { if (insn.getOpcode() == PUTFIELD && Value.isComposite(value2)) { throw new IllegalStateException("could not trace " + value2 + " over putfield"); } return super.binaryOperation(insn, value1, value2); } @Override public BasicValue ternaryOperation(AbstractInsnNode insn, BasicValue value1, BasicValue value2, BasicValue value3) throws AnalyzerException { if (insn.getOpcode() == AASTORE && Value.isComposite(value3)) { throw new IllegalStateException("could not trace " + value3 + " over aastore"); } return super.ternaryOperation(insn, value1, value2, value3); } @Override public BasicValue unaryOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { if (Value.isComposite(value)) { switch (insn.getOpcode()) { case PUTSTATIC: { throw new IllegalStateException("could not trace " + value + " over putstatic"); } ... } } return super.unaryOperation(insn, value); }

. checkcast . : . —

 Client client1 = ...; Object objClient = client1; Client client2 = (Client) objClient;

, . , , client1 objClient , . , checkcast .

 class Foo { private List<?> list; public void trimToSize() { ((ArrayList<?>) list).trimToSize(); } }

. , , , . , , , , , . ? , ! . , , , null/0/false. . —

 @JdbcJoinedObject(localColumn = "CLIENT") private Client client;

, , ORM , . checkcast

 @Override public BasicValue unaryOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { if (Value.isComposite(value)) { switch (insn.getOpcode()) { ... case CHECKCAST: { Class<?> original = reflectClass(value.getType()); Type targetType = getObjectType(((TypeInsnNode) insn).desc); Class<?> afterCast = reflectClass(targetType); if (afterCast.isAssignableFrom(original)) { return value; } else { throw new IllegalStateException("type specification not supported"); } } } } return super.unaryOperation(insn, value); }

— getfield . — ?

 class Foo { private Foo child; public Foo test() { Foo loopedRef = this; while (ThreadLocalRandom.current().nextBoolean()) { loopedRef = loopedRef.child; } return loopedRef; } }

, . ? child , child.child , child.child.child ? ? , . , . ,

null.

child, null, , , . Ref.childRef

 if (parent.path.contains(field)) return empty();

. , .

" ". . , . , , ( @JdbcJoinedObject , @JdbcColumn ), , . ORM .

, getfield , . , , , . — .

 @Override public BasicValue unaryOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { if (Value.isComposite(value)) { switch (insn.getOpcode()) { ... case GETFIELD: { Optional<Value> optionalFieldValue = childValue((Value) value, (FieldInsnNode) insn, configuration); if (!optionalFieldValue.isPresent()) break; Value fieldValue = optionalFieldValue.get(); if (configuration.isInterestingField(resolveField((FieldInsnNode) insn))) { context.addUsedField(fieldValue); } if (Value.isComposite(fieldValue)) { return fieldValue; } break; } ... } } return super.unaryOperation(insn, value); }

. , , . , invoke* . , , , . , :

 public long getClientId() { return getClient().getId(); }

, , . , . . , . ? . . .

 class Account implements HasClient { @JdbcJoinedObject private Client client; public Client getClient() { return client; } }

Account.client . , . . — , .

 public static class Result { private final Set<Value> usedFields; private final Value returnedCompositeValue; }

? , . . , .. ( , — ), , areturn , , , *return . MethodNode ( , Tree API) . . — . , ? . .

 private static Value getReturnedCompositeValue(Frame<BasicValue>[] frames, AbstractInsnNode[] insns) { Set<Value> resultValues = new HashSet<>(); for (int i = 0; i < insns.length; i++) { AbstractInsnNode insn = insns[i]; switch (insn.getOpcode()) { case IRETURN: case LRETURN: case FRETURN: case DRETURN: case ARETURN: BasicValue value = frames[i].getStack(0); if (Value.isComposite(value)) { resultValues.add((Value) value); } break; } } if (resultValues.isEmpty()) return null; return mergeValues(resultValues); }

analyzeField

 public static Result analyzeField(Method method, Configuration configuration) { if (Modifier.isNative(method.getModifiers())) throw new IllegalStateException("could not analyze native method " + method); MethodInfo methodInfo = readMethod(method); MethodNode mn = methodInfo.getMethodNode(); String internalClassName = methodInfo.getInternalDeclaringClassName(); int classAccess = methodInfo.getClassAccess(); Context context = new Context(method, classAccess); FieldsInterpreter interpreter = new FieldsInterpreter(context, configuration); Analyzer<BasicValue> analyzer = new Analyzer<>(interpreter); try { analyzer.analyze(internalClassName, mn); } catch (AnalyzerException e) { throw new RuntimeException(e); } Frame<BasicValue>[] frames = analyzer.getFrames(); AbstractInsnNode[] insns = mn.instructions.toArray(); Value returnedCompositeValue = getReturnedCompositeValue(frames, insns); return new Result(context.getUsedFields(), returnedCompositeValue); }

, -, . invoke* . 5 :

invokespecial — . , , ( super.call() ).
invokevirtual — . . , .
invokeinterface — , invokevirtual , — .
invokestatic —
invokedynamic — , 7 JSR 292. JVM, invokedynamic ( dynamic). , (+ ), . , Invokedynamic: ? ।

, , , . invokedynamic , . , , , (, ), invokedynamic . , "" . , invokedynamic , .

. , . , . , this , 0? , - , FieldsInterpreter copyOperation . , MethodAnalyzer.analyzeFields " this " " " ( this — ). , . , , . , - . , (- Optional.ofNullable(client) ). .

, invokestatic (.. , this ). invokespecial , invokevirtual invokeinterface . , . , , jvm. invokespecial , , . invokevirtual invokeinterface . , .

 public String objectToString(Object obj) { return obj.toString(); }

 public static java.lang.String objectToString(java.lang.Object); Code: 0: aload_0 1: invokevirtual #104 // Method java/lang/Object.toString:()Ljava/lang/String; 4: areturn

, , ( ) . , , . ? ORM . ORM , , . invokevirtual invokeinterface .

हुर्रे! . आगे क्या है? , ( , this ), ( , ) . !

  @Override public BasicValue naryOperation(AbstractInsnNode insn, List<? extends BasicValue> values) throws AnalyzerException { Method method = null; Value methodThis = null; switch (insn.getOpcode()) { case INVOKESPECIAL: {...} case INVOKEVIRTUAL: {...} case INVOKEINTERFACE: { if (Value.isComposite(values.get(0))) { MethodInsnNode methodNode = (MethodInsnNode) insn; Class<?> objectClass = reflectClass(values.get(0).getType()); Method interfaceMethod = resolveInterfaceMethod(reflectClass(methodNode.owner), methodNode.name, getMethodType(methodNode.desc)); method = lookupInterfaceMethod(objectClass, interfaceMethod); methodThis = (Value) values.get(0); } List<?> badValues = values.stream().skip(1).filter(Value::isComposite).collect(toList()); if (!badValues.isEmpty()) throw new IllegalStateException("could not pass " + badValues + " as parameter"); break; } case INVOKESTATIC: case INVOKEDYNAMIC: { List<?> badValues = values.stream().filter(Value::isComposite).collect(toList()); if (!badValues.isEmpty()) throw new IllegalStateException("could not pass " + badValues + " as parameter"); break; } } if (method != null) { MethodAnalyzer.Result methodResult = analyzeFields(method, configuration); for (Value usedField : methodResult.getUsedFields()) { childValue(methodThis, usedField).ifPresent(context::addUsedField); } if (methodResult.getReturnedCompositeValue() != null) { Optional<Value> returnedValue = childValue(methodThis, methodResult.getReturnedCompositeValue()); if (returnedValue.isPresent()) { return returnedValue.get(); } } } return super.naryOperation(insn, values); }

. , . , JVMS 1 1. . — . , , . , .. , - , 2 — . , , . , — . , ResolutionUtil LookupUtil .

.

, 80% 20% 20% 80% . , , , ?

. (.. ), . , . , .

 public class Account { private Client client; public Long getClientId() { return Optional.ofNullable(client).map(Client::getId).orElse(null); } }

Optional , ofNullable getClientId , , value . , returnedCompositeValue — , , . , , ( ) , . -. , , , " value Optional@1234 Client@5678 " .

invokedynamic , . indy , . , . , . , invokedynamic. . . , java.lang.invoke.LambdaMetafactory.metafactory . , , , . java.lang.invoke.StringConcatFactory.makeConcat/makeConcatWithConstants . . toString() . , , , , . , , , /- . jvm, . , , . . . , , . indy . ? indy , — CallSite . . , , LambdaMetafactory.metafactory getValue , . getValue . ( ) . , , , stateless. , ! - , . CallSite ConstantCallSite , MutableCallSite VolatileCallSite . mutable volatile , , ConstantCallSite . "- ". , , . , VM, .

अंतभाषण

- , . - partialGet . , . , , , , " " .

, .

हम अधिकतम करने का प्रयास करते हैं: ओआरएम से बाइटकोड विश्लेषण तक