जावा ऑब्जेक्ट (बीन) को कुंजी-मूल्य जोड़े (और इसके विपरीत) में कैसे परिवर्तित किया जाए?

Question

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

इस रूपांतरण को करने के लिए प्रतिबिंब या मैन्युअल रूप से लिखने के अलावा, इसे प्राप्त करने का सबसे अच्छा तरीका क्या है?

एक उदाहरण ObjectMessage प्रकार का उपयोग किए बिना (या आने वाली संदेश को सही प्रकार की वस्तु में परिवर्तित करके) इस ऑब्जेक्ट को jms पर भेजा जा सकता है।

Comments

java.beans.Introspector.getBeanInfo()। यह सही JDK में बनाया गया है।

— लोर्ने

Answer 1

हमेशा अपाचे कॉमन्स बीनटिल्स होते हैं लेकिन निश्चित रूप से यह हुड के नीचे प्रतिबिंब का उपयोग करता है

Comments

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

— स्टैक्समैन

सटीक होने के लिए, बीनपाइप (बीन) आम बीनटिल्स का विशिष्ट हिस्सा है जो चाल करता है।

— vdr

प्रदर्शन के विचारों की अवहेलना करते हुए मैंने पाया है कि नीचे दिए गए जवाब से जैक्सन के ऑब्जेक्टमैपर के साथ संयोजन में बीनपैम () का उपयोग करने से मुझे सबसे अच्छे परिणाम मिले। बीनपॉपर मेरी वस्तु का अधिक पूर्ण नक्शा बनाने में सफल रहा और फिर जैक्सन ने इसे सादे लिंक्डहैशपॉफ़्ट संरचना में बदल दिया, जिसने पाइपलाइन के नीचे संशोधनों की अनुमति दी। objectAsMap = objectMapper.convertValue (नया बीनपॉपर (myObject), Map.class);

— michaelr524

एंड्रॉइड पर काम नहीं करेगा क्योंकि यह java.beansप्लेटफॉर्म पर निर्भरता को गंभीर रूप से सीमित करता है। देखें संबंधित सवाल जानकारी के लिए।

— स्क्वीज़ीमो

अपाचे कॉमन्स का उल्लेख करने वाला एक समाधान सबसे अच्छा समाधान है।

— рüффп

Answer 2

संभावित समाधान के बहुत सारे, लेकिन चलो सिर्फ एक और जोड़ें। उपयोग जैक्सन (JSON प्रसंस्करण lib) करने के लिए "json-कम" रूपांतरण, जैसे:

ObjectMapper m = new ObjectMapper();
Map<String,Object> props = m.convertValue(myBean, Map.class);
MyBean anotherBean = m.convertValue(props, MyBean.class);

( इस ब्लॉग प्रविष्टि के कुछ और उदाहरण हैं)

आप मूल रूप से किसी भी संगत प्रकार को परिवर्तित कर सकते हैं: संगत अर्थ है कि अगर आपने टाइप से JSON में परिवर्तित किया है, और उस JSON से परिणाम प्रकार में, प्रविष्टियां मेल खाएगी (यदि ठीक से कॉन्फ़िगर किया गया है तो बिना मान्यता प्राप्त लोगों को भी अनदेखा कर सकते हैं)।

उन मामलों के लिए अच्छी तरह से काम करता है, जिनमें मैप्स, लिस्ट्स, एरेज़, प्राइमेटिव्स, बीन-जैसे पीओजेओ शामिल हैं।

Comments

यह स्वीकृत उत्तर होना चाहिए। BeanUtilsअच्छा है, लेकिन एरे और एनम को संभाल नहीं सकते

— मनीष पटेल

Answer 3

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

Comments

प्रदर्शन महत्वपूर्ण है इसलिए मुझे लगता है कि प्रतिबिंब बाहर है। मैं उम्मीद कर रहा था कि कुछ ऐसे उपकरण हो सकते हैं जो asm या cglib का उपयोग करते हैं। मैंने Google के प्रोटोकॉल बफ़र्स को फिर से देखना शुरू कर दिया है। मुझे JMS के बारे में आपकी टिप्पणी नहीं मिली, मैं इसका उपयोग मशीनों पर जानकारी संप्रेषित करने के लिए कर रहा हूँ।

— शहबाज

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

— माइकल बोर्गवर्ड्ट

यही मेरा विचार भी है। या तो आप प्रतिबिंब का उपयोग करते हैं (प्रत्यक्ष या अप्रत्यक्ष रूप से) या आपको कोड उत्पन्न करना होगा। (या खुद अतिरिक्त कोड लिखें)।

— एक्सट्रैनन

Answer 4

यह जावा ऑब्जेक्ट को मैप में बदलने के लिए एक विधि है

public static Map<String, Object> ConvertObjectToMap(Object obj) throws 
    IllegalAccessException, 
    IllegalArgumentException, 
    InvocationTargetException {
        Class<?> pomclass = obj.getClass();
        pomclass = obj.getClass();
        Method[] methods = obj.getClass().getMethods();


        Map<String, Object> map = new HashMap<String, Object>();
        for (Method m : methods) {
           if (m.getName().startsWith("get") && !m.getName().startsWith("getClass")) {
              Object value = (Object) m.invoke(obj);
              map.put(m.getName().substring(3), (Object) value);
           }
        }
    return map;
}

इसको कैसे बुलाना है

   Test test = new Test()
   Map<String, Object> map = ConvertObjectToMap(test);

Comments

मुझे नहीं लगता कि वांछित उत्तर प्रत्येक ऑब्जेक्ट पर परिभाषित तरीकों पर निर्भर करता है, प्रतिबिंब की तरह लगता है।

— रॉबर्ट कार्ल

मुझे नहीं पता कि आपके उद्देश्य आपकी विधि है। लेकिन मुझे लगता है कि यह बहुत ही उत्कृष्ट उदाहरण है जब आप सामान्य प्रकार की वस्तुओं के साथ प्रोग्रामिंग करना चाहते हैं

— DeXoN

Answer 5

शायद पार्टी के लिए देर हो चुकी है। आप जैक्सन का उपयोग कर सकते हैं और इसे एक गुण ऑब्जेक्ट में परिवर्तित कर सकते हैं। यह नेस्टेड वर्गों के लिए अनुकूल है और यदि आप एबीसी = मान के लिए कुंजी चाहते हैं।

JavaPropsMapper mapper = new JavaPropsMapper();
Properties properties = mapper.writeValueAsProperties(sct);
Map<Object, Object> map = properties;

यदि आप कुछ प्रत्यय चाहते हैं, तो बस करें

SerializationConfig config = mapper.getSerializationConfig()
                .withRootName("suffix");
mapper.setConfig(config);

इस निर्भरता को जोड़ने की जरूरत है

<dependency>
  <groupId>com.fasterxml.jackson.dataformat</groupId>
  <artifactId>jackson-dataformat-properties</artifactId>
</dependency>

Answer 6

जावा 8 के साथ आप यह कोशिश कर सकते हैं:

public Map<String, Object> toKeyValuePairs(Object instance) {
    return Arrays.stream(Bean.class.getDeclaredMethods())
            .collect(Collectors.toMap(
                    Method::getName,
                    m -> {
                        try {
                            Object result = m.invoke(instance);
                            return result != null ? result : "";
                        } catch (Exception e) {
                            return "";
                        }
                    }));
}

Answer 7

JSON , उदाहरण के लिए XStream + Jettison का उपयोग कर रहा है, कुंजी मूल्य जोड़े के साथ एक सरल पाठ प्रारूप है। यह उदाहरण के लिए Apache ActiveMQ JMS संदेश ब्रोकर द्वारा जावा प्लेटफ़ॉर्म एक्सचेंज के लिए अन्य प्लेटफार्मों / भाषाओं के साथ समर्थित है।

Answer 8

बस प्रतिबिंब और ग्रूवी का उपयोग कर:

def Map toMap(object) {             
return object?.properties.findAll{ (it.key != 'class') }.collectEntries {
            it.value == null || it.value instanceof Serializable ? [it.key, it.value] : [it.key,   toMap(it.value)]
    }   
}

def toObject(map, obj) {        
    map.each {
        def field = obj.class.getDeclaredField(it.key)
        if (it.value != null) {
            if (field.getType().equals(it.value.class)){
                obj."$it.key" = it.value
            }else if (it.value instanceof Map){
                def objectFieldValue = obj."$it.key"
                def fieldValue = (objectFieldValue == null) ? field.getType().newInstance() : objectFieldValue
                obj."$it.key" = toObject(it.value,fieldValue) 
            }
        }
    }
    return obj;
}

Comments

शांत लेकिन StackOverflowError के लिए प्रवण

— Teo Choong पिंग

Answer 9

जफ़र-प्रतिबिंबित का उपयोग करें BeanWrapper। यह बहुत अच्छा प्रदर्शन करने वाला है।

यहाँ आप एक बीन को एक नक्शे में कैसे बदल सकते हैं:

public static Map<String, Object> getBeanMap(Object bean) {
    Map<String, Object> beanMap = new HashMap<String, Object>();
    BeanWrapper beanWrapper = new BeanWrapper(BeanWrapperContext.create(bean.getClass()));
    for(String propertyName : beanWrapper.getPropertyNames())
        beanMap.put(propertyName, beanWrapper.getValue(propertyName));
    return beanMap;
}

मैंने खुद जाफर को विकसित किया। यह खुला स्रोत है, इसलिए आप इसका उपयोग करने और संशोधित करने के लिए स्वतंत्र हैं। और अगर आपके पास इसके बारे में कोई सवाल है, तो मुझे जवाब देने में खुशी होगी।

चियर्स

कार्लोस

Comments

मैंने इसके बारे में सोचा और महसूस किया कि यदि आप बीन ग्राफ में परिपत्र संदर्भ रखते हैं तो मेरा पहले वाला समाधान टूट जाता है। इसलिए मैंने एक तरीका विकसित किया जो पारदर्शी तरीके से करेगा और परिपत्र संदर्भों को खूबसूरती से संभालता है। अब आप बीन को एक नक्शे में बदल सकते हैं और इसके विपरीत को जफ़र-प्रतिबिंबित के साथ बदल सकते हैं। आनंद लें :)

— Martins

Answer 10

स्प्रिंग का उपयोग करते समय, कोई स्प्रिंग इंटीग्रेशन ऑब्जेक्ट-टू-मैप-ट्रांसफार्मर का भी उपयोग कर सकता है। यह शायद वसंत को सिर्फ एक निर्भरता के रूप में जोड़ने के लायक नहीं है।

प्रलेखन के लिए, http://docs.spring.io/spring-integration/docs/4.0.4.RELEASE/reference/html/messaging-transformation-chapter.html पर "ऑब्जेक्ट-टू-मैप ट्रांसफार्मर" खोजें।

अनिवार्य रूप से, यह इनपुट के रूप में दी गई वस्तु से पूरे ऑब्जेक्ट ग्राफ को हटा देता है, और ऑब्जेक्ट्स पर सभी आदिम प्रकार / स्ट्रिंग फ़ील्ड से एक मानचित्र बनाता है। इसे आउटपुट में कॉन्फ़िगर किया जा सकता है:

• एक सपाट नक्शा: {rootObject.someField = Joe, rootObject.leafObject.someField = जेन}, या
• एक संरचित नक्शा: {someField = जो, लीफऑब्जेक्ट = {someField = जेन}}।

यहाँ उनके पृष्ठ से एक उदाहरण दिया गया है:

public class Parent{
    private Child child;
    private String name; 
    // setters and getters are omitted
}

public class Child{
   private String name; 
   private List<String> nickNames;
   // setters and getters are omitted
}

आउटपुट होगा:

{person.name = जॉर्ज, person.child.name = जेन्ना, person.child.nickNames [0] = बिंबो। । । आदि}

एक रिवर्स ट्रांसफार्मर भी उपलब्ध है।

Answer 11

आप Joda ढांचे का उपयोग कर सकते हैं:

http://joda.sourceforge.net/

और JodaProperties का लाभ उठाएं। इससे यह निर्धारित होता है कि आप एक विशेष तरीके से बीन्स बनाते हैं, और एक विशिष्ट इंटरफ़ेस लागू करते हैं। हालांकि, यह आपको प्रतिबिंब के बिना, एक विशिष्ट वर्ग से एक संपत्ति का नक्शा वापस करने की अनुमति देता है। नमूना कोड यहाँ है:

http://pbin.oogly.co.uk/listings/viewlistingdetail/0e78eb6c76d071b4e22bbcac748c57

Comments

दिलचस्प लग रहा है, दुर्भाग्य से यह नहीं लगता है कि यह किसी भी अधिक बनाए रखा है। इसके अलावा, यह जिस संपत्ति का नक्शा देता है, वह <स्ट्रिंग, स्ट्रिंग> का मानचित्र होता है, इसलिए सुरक्षित नहीं है।

— शाहबाज

सच है, यह 2002 के बाद से बनाए नहीं रखा गया है। मैं सिर्फ इस बात के लिए उत्सुक था कि क्या एक गैर-प्रतिबिंब आधारित समाधान मौजूद था। संपत्ति का नक्शा यह रिटर्न वास्तव में सिर्फ एक मानक नक्शा है, इस तरह के रूप में कोई जेनरिक ...

— जॉन

Answer 12

यदि आप प्रत्येक गेट्टर और सेटर को हार्डकोड कॉल नहीं करना चाहते हैं, तो प्रतिबिंब इन तरीकों को कॉल करने का एकमात्र तरीका है (लेकिन यह कठिन नहीं है)।

क्या आप वास्तविक डेटा को होल्ड करने के लिए एक प्रॉपर्टी ऑब्जेक्ट का उपयोग करने के लिए विचाराधीन वर्ग को रिफलेक्टर कर सकते हैं, और प्रत्येक गेट्टर और सेटर को बस कॉल / गेट सेट कर सकते हैं? फिर आपके पास एक ऐसी संरचना है जो आप करना चाहते हैं। कुंजी-मान फ़ॉर्म में उन्हें सहेजने और लोड करने की भी विधियाँ हैं।

Comments

कोई विधियाँ नहीं हैं, क्योंकि यह आप पर निर्भर करता है कि एक कुंजी क्या है और मूल्य क्या है! ऐसी सेवा लिखना आसान होना चाहिए जो इस तरह का रूपांतरण करती है। एक सरल प्रतिनिधित्व के लिए CSV स्वीकार्य हो सकता है।

— मार्टिन के।

Answer 13

सबसे अच्छा उपाय डोजर का उपयोग करना है। आपको मैपर फ़ाइल में बस कुछ इस तरह की आवश्यकता है:

<mapping map-id="myTestMapping">
  <class-a>org.dozer.vo.map.SomeComplexType</class-a>
  <class-b>java.util.Map</class-b>
</mapping> 

और यह बात है, डोजर बाकी की देखभाल करता है !!!

डोजर डॉक्यूमेंटेशन URL

Comments

इसे मैपिंग फ़ाइल की आवश्यकता क्यों है? यदि यह पता है कि कैसे परिवर्तित किया जाए, तो इस अतिरिक्त कार्य की आवश्यकता क्यों है - बस स्रोत वस्तु, अपेक्षित प्रकार लें?

— स्टैक्मैन मैन 19’10

ठीक। कारण जानना अच्छा है, भले ही मुझे यकीन नहीं है कि यह वैध है :)

— StaxMan

Answer 14

निश्चित रूप से रूपांतरण के पूर्ण सरलतम साधन संभव हैं - कोई भी रूपांतरण नहीं!

कक्षा में परिभाषित निजी चर का उपयोग करने के बजाय, कक्षा को केवल एक HashMap शामिल करें जो उदाहरण के लिए मानों को संग्रहीत करता है।

फिर आपके गेटर्स और सेटर्स लौटाते हैं और मूल्यों को हाशप के अंदर और बाहर सेट करते हैं, और जब इसे मैप, वॉइला में बदलने का समय होता है! - यह पहले से ही एक नक्शा है।

थोड़ा एओपी मैजरी के साथ, आप एक बीन में निहित अनम्यता को भी बनाए रख सकते हैं, जिससे आप अभी भी गेटर्स का उपयोग कर सकते हैं और प्रत्येक मूल्यों के नाम के लिए विशिष्ट सेट कर सकते हैं, वास्तव में व्यक्तिगत गेटर्स को लिखने और बसने के बिना।

Answer 15

आप जावा 8 स्ट्रीम फ़िल्टर कलेक्टर गुण का उपयोग कर सकते हैं,

public Map<String, Object> objectToMap(Object obj) {
    return Arrays.stream(YourBean.class.getDeclaredMethods())
            .filter(p -> !p.getName().startsWith("set"))
            .filter(p -> !p.getName().startsWith("getClass"))
            .filter(p -> !p.getName().startsWith("setClass"))
            .collect(Collectors.toMap(
                    d -> d.getName().substring(3),
                    m -> {
                        try {
                            Object result = m.invoke(obj);
                            return result;
                        } catch (Exception e) {
                            return "";
                        }
                    }, (p1, p2) -> p1)
            );
}

Answer 16

मेरा जावाड्यूड बीन एनोटेशन प्रोसेसर ऐसा करने के लिए कोड तैयार करता है।

http://javadude.googlecode.com

उदाहरण के लिए:

@Bean(
  createPropertyMap=true,
  properties={
    @Property(name="name"),
    @Property(name="phone", bound=true),
    @Property(name="friend", type=Person.class, kind=PropertyKind.LIST)
  }
)
public class Person extends PersonGen {}

उपरोक्त सुपरक्लास पर्सनजेन उत्पन्न करता है जिसमें एक createPropertyMap () विधि शामिल है जो @Bean का उपयोग करके परिभाषित सभी गुणों के लिए एक मानचित्र तैयार करता है।

(ध्यान दें कि मैं एपीआई को अगले संस्करण के लिए थोड़ा बदल रहा हूं - एनोटेशन विशेषता को परिभाषित किया जाएगा ।CreatePropertyMap = true)

Comments

क्या आपने कोड-समीक्षाएं की हैं? यह एक अच्छा तरीका नहीं है! आप एनोटेशन के साथ वंशानुक्रम पथ को बदलते हैं! क्या होगा अगर सेम पहले से ही एक वर्ग में फैली हुई है ?! आपके पास दो बार विशेषताएँ लिखने के लिए क्यों है?

— मार्टिन के।

यदि आपके पास पहले से ही एक सुपरक्लास है, तो आप @ बीन (सुपरक्लास = XXX.class, ...) का उपयोग करते हैं और यह उत्पन्न सुपरक्लास इनबेटन को सम्मिलित करता है। यह कोड समीक्षाओं के लिए बहुत अच्छा रहा है - हालांकि कम संभावित त्रुटि-प्रवण बॉयलरप्लेट को झारना।

— स्कॉट स्टैनफील्ड

सुनिश्चित नहीं हैं कि आपके द्वारा "दो बार विशेषताएँ लिखें" से क्या मतलब है - वे दो बार कहाँ दिखाते हैं?

— स्कॉट स्टैनफील्ड

@ मर्टिन के। यदि आप वास्तव में हूड के तहत भी प्रतिबिंब का उपयोग नहीं करना चाहते हैं, तो आप शायद किसी प्रकार की कोड पीढ़ी करने के लिए मजबूर हैं।

— एक्सट्रैनन

Answer 17

आपको एक सामान्य परिवर्तन सेवा लिखना चाहिए! इसे मुक्त रखने के लिए जेनरिक का उपयोग करें (ताकि आप हर वस्तु को कुंजी => मूल्य और पीठ में बदल सकें)।

किस क्षेत्र की कुंजी होनी चाहिए? बीन से उस क्षेत्र को प्राप्त करें और किसी अन्य गैर क्षणिक मान को एक मूल्य मानचित्र में जोड़ें।

जिस तरह से वापस बहुत आसान है। कुंजी (x) पढ़ें और पहले कुंजी पर लिखें और फिर प्रत्येक सूची एक नई वस्तु में वापस प्रवेश करती है।

आप अपाचे कॉमन बीनटिल्स के साथ एक बीन की संपत्ति के नाम प्राप्त कर सकते हैं !

Answer 18

यदि आप वास्तव में प्रदर्शन चाहते हैं तो आप कोड जनरेशन रूट पर जा सकते हैं।

आप अपने स्वयं के प्रतिबिंब और एक मिश्रण AspectJ ITD का निर्माण करके अपने दम पर ऐसा कर सकते हैं।

या आप स्प्रिंग रो का उपयोग कर सकते हैं और स्प्रिंग रो एडोन बना सकते हैं । आपका Roo addon उपरोक्त के समान कुछ करेगा, लेकिन सभी के लिए उपलब्ध होगा जो Spring Roo का उपयोग करता है और आपको Runtime Annotations का उपयोग करने की आवश्यकता नहीं है।

मैंने दोनों किया है। लोग स्प्रिंग रो पर बकवास करते हैं लेकिन यह वास्तव में जावा के लिए सबसे व्यापक कोड पीढ़ी है।

Answer 19

एक अन्य संभव तरीका यहाँ है।

बीनवैपर संपत्ति मूल्यों (व्यक्तिगत रूप से या थोक में) को सेट करने और प्राप्त करने के लिए कार्यक्षमता प्रदान करता है, संपत्ति विवरणक प्राप्त करता है, और गुणों को निर्धारित करने के लिए कि क्या वे पठनीय या योग्य हैं।

Company c = new Company();
 BeanWrapper bwComp = BeanWrapperImpl(c);
 bwComp.setPropertyValue("name", "your Company");

Answer 20

यदि यह कुंजी मूल्य सूची मैपिंग के लिए एक साधारण ऑब्जेक्ट ट्री की बात आती है, जहां कुंजी का मूल तत्व से पत्ती के निरीक्षण के लिए एक डॉटेड पथ विवरण हो सकता है, तो यह स्पष्ट है कि कुंजी-मूल्य सूची में एक पेड़ रूपांतरण एक में तुलनीय है; xml मानचित्रण के लिए ऑब्जेक्ट। XML दस्तावेज़ के भीतर प्रत्येक तत्व में एक परिभाषित स्थिति होती है और इसे एक पथ में परिवर्तित किया जा सकता है। इसलिए मैंने XStream को एक बुनियादी और स्थिर रूपांतरण उपकरण के रूप में लिया और खुद के कार्यान्वयन के साथ पदानुक्रमित ड्राइवर और लेखक भागों को बदल दिया। XStream एक बुनियादी पथ ट्रैकिंग तंत्र के साथ भी आता है - जिसे अन्य दो के साथ जोड़ा जा रहा है - सख्ती से कार्य के लिए उपयुक्त समाधान होता है।

Answer 21

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

TestClass testObject = new TestClass();
com.fasterxml.jackson.databind.ObjectMapper m = new com.fasterxml.jackson.databind.ObjectMapper();

Map<String,Object> props = m.convertValue(testObject, Map.class);

for(Map.Entry<String, Object> entry : props.entrySet()){
    if(entry.getValue() instanceof String || entry.getValue() instanceof Integer || entry.getValue() instanceof Double){
        System.out.println(entry.getKey() + "-->" + entry.getValue());
    }
}

Answer 22

Gson का उपयोग करके,

1. POJO कन्वर्ट करें object Json करने के लिए

2. Json को मैप में बदलें

       retMap = new Gson().fromJson(new Gson().toJson(object), 
               new TypeToken<HashMap<String, Object>>() {}.getType()
       );

Answer 23

जावा ऑब्जेक्ट को आसानी से मैप में बदलने के लिए हम जैक्सन लाइब्रेरी का उपयोग कर सकते हैं।

<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.6.3</version>
</dependency>

अगर एंड्रॉइड प्रोजेक्ट में उपयोग कर रहे हैं, तो आप अपने ऐप के बिल्ड.ग्रेड में जैकसन जोड़ सकते हैं:

implementation 'com.fasterxml.jackson.core:jackson-core:2.9.8'
implementation 'com.fasterxml.jackson.core:jackson-annotations:2.9.8'
implementation 'com.fasterxml.jackson.core:jackson-databind:2.9.8'

नमूना कार्यान्वयन

public class Employee {

    private String name;
    private int id;
    private List<String> skillSet;

    // getters setters
}

public class ObjectToMap {

 public static void main(String[] args) {

    ObjectMapper objectMapper = new ObjectMapper();

    Employee emp = new Employee();
    emp.setName("XYZ");
    emp.setId(1011);
    emp.setSkillSet(Arrays.asList("python","java"));

    // object -> Map
    Map<String, Object> map = objectMapper.convertValue(emp, 
    Map.class);
    System.out.println(map);

 }

}

आउटपुट:

{नाम = XYZ, आईडी = 1011, कौशल = [अजगर, जावा]}