วิธีการแปลงวัตถุ Java (bean) เป็นคู่คีย์ - ค่า (และในทางกลับกัน)?

Question 1

สมมติว่าฉันมีวัตถุ java ที่เรียบง่ายซึ่งมีคุณสมบัติ getXXX และ setXXX บางอย่างเท่านั้น อ็อบเจ็กต์นี้ใช้เพื่อจัดการกับค่าเท่านั้นโดยทั่วไปคือเรกคอร์ดหรือแผนที่ชนิดปลอดภัย (และตัวแสดง) ฉันมักจะต้องแอบแฝงวัตถุนี้เป็นคู่ค่าคีย์ (สตริงหรือประเภทปลอดภัย) หรือแปลงจากคู่ค่าคีย์เป็นวัตถุนี้

นอกเหนือจากการสะท้อนกลับหรือเขียนโค้ดด้วยตนเองเพื่อทำการแปลงนี้วิธีใดที่ดีที่สุดในการบรรลุเป้าหมายนี้

ตัวอย่างอาจส่งวัตถุนี้ผ่าน jms โดยไม่ใช้ประเภท ObjectMessage (หรือแปลงข้อความขาเข้าเป็นชนิดของวัตถุที่ถูกต้อง)

Question 2

มักจะมีถั่วลิสง apache คอมมอนส์อยู่เสมอแต่แน่นอนว่ามันใช้การสะท้อนใต้ฝากระโปรง

Question 3

วิธีแก้ปัญหาที่เป็นไปได้มากมาย แต่ขอเพิ่มอีกหนึ่งข้อ ใช้Jackson (JSON processing lib) เพื่อทำการแปลง "json-less" เช่น:

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

( รายการบล็อกนี้มีตัวอย่างเพิ่มเติม)

โดยทั่วไปคุณสามารถแปลงประเภทที่เข้ากันได้: หมายความว่าเข้ากันได้ว่าถ้าคุณแปลงจากประเภทเป็น JSON และจาก JSON นั้นเป็นประเภทผลลัพธ์รายการจะตรงกัน (หากกำหนดค่าอย่างถูกต้องสามารถละเว้นประเภทที่ไม่รู้จักได้)

ใช้งานได้ดีกับกรณีที่คาดหวังรวมถึง Maps, Lists, อาร์เรย์, แบบดั้งเดิม, POJO แบบถั่ว

Question 4

การสร้างรหัสจะเป็นวิธีเดียวที่ฉันคิดได้ โดยส่วนตัวแล้วฉันได้รับโซลูชันการสะท้อนกลับที่ใช้ซ้ำได้โดยทั่วไป (เว้นแต่ส่วนนั้นของโค้ดจะมีความสำคัญต่อประสิทธิภาพอย่างยิ่ง) การใช้ JMS ดูเหมือน overkill (การพึ่งพาเพิ่มเติมและนั่นไม่ใช่สิ่งที่หมายถึง) นอกจากนี้อาจใช้การสะท้อนเช่นกันภายใต้ฝากระโปรง

Question 5

นี่เป็นวิธีการแปลงวัตถุ Java เป็นแผนที่

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);

Question 6

อาจจะสายไปงานปาร์ตี้ คุณสามารถใช้ Jackson และแปลงเป็นวัตถุ Properties ได้ สิ่งนี้เหมาะสำหรับคลาสที่ซ้อนกันและหากคุณต้องการคีย์ใน for abc = value

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>

Question 7

ด้วย Java 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 "";
                        }
                    }));
}

Question 8

JSONเช่นการใช้ XStream + Jettison เป็นรูปแบบข้อความธรรมดาที่มีคู่คีย์ค่า ได้รับการสนับสนุนโดยนายหน้าข้อความ Apache ActiveMQ JMS สำหรับการแลกเปลี่ยนวัตถุ Java กับแพลตฟอร์ม / ภาษาอื่น ๆ

Question 9

เพียงแค่ใช้การสะท้อนและ Groovy:

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;
}

Question 10

ใช้juffrou-reflect reflect มันมีประสิทธิภาพมาก

นี่คือวิธีที่คุณสามารถเปลี่ยนถั่วเป็นแผนที่:

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;
}

ฉันพัฒนา Juffrou ด้วยตัวเอง เป็นโอเพนซอร์สดังนั้นคุณจึงมีอิสระที่จะใช้และแก้ไข และหากคุณมีคำถามใด ๆ เกี่ยวกับเรื่องนี้เรายินดีเป็นอย่างยิ่งที่จะตอบกลับ

ไชโย

คาร์ลอส

Question 11

เมื่อใช้ Spring เราสามารถใช้ Spring Integration object-to-map-transformer อาจไม่คุ้มค่าที่จะเพิ่ม Spring เป็นการพึ่งพาเพียงแค่นี้

สำหรับเอกสารให้ค้นหา "Object-to-Map Transformer" ในhttp://docs.spring.io/spring-integration/docs/4.0.4.RELEASE/reference/html/messaging-transformation-chapter.html

โดยพื้นฐานแล้วมันจะข้ามกราฟวัตถุทั้งหมดที่สามารถเข้าถึงได้จากวัตถุที่กำหนดให้เป็นอินพุตและสร้างแผนที่จากฟิลด์ประเภท / สตริงดั้งเดิมทั้งหมดบนวัตถุ สามารถกำหนดค่าให้เอาต์พุตได้:

แผนที่แบบแบน: {rootObject.someField = Joe, rootObject.leafObject.someField = Jane} หรือ
แผนที่ที่มีโครงสร้าง: {someField = Joe, leafObject = {someField = Jane}}

นี่คือตัวอย่างจากเพจของพวกเขา:

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 = George, person.child.name = Jenna, person.child.nickNames [0] = Bimbo . . ฯลฯ }

นอกจากนี้ยังมีหม้อแปลงไฟฟ้าย้อนกลับ

Question 12

คุณสามารถใช้ Joda framework:

http://joda.sourceforge.net/

และใช้ประโยชน์จาก JodaProperties สิ่งนี้กำหนดให้คุณสร้างถั่วด้วยวิธีเฉพาะและใช้อินเทอร์เฟซเฉพาะ อย่างไรก็ตามจะอนุญาตให้คุณส่งคืนแผนที่คุณสมบัติจากคลาสเฉพาะโดยไม่ต้องสะท้อนกลับ โค้ดตัวอย่างอยู่ที่นี่:

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

Question 13

หากคุณไม่ต้องการฮาร์ดโค้ดเรียกไปยัง getter และ setter แต่ละตัวการสะท้อนเป็นวิธีเดียวที่จะเรียกเมธอดเหล่านี้ (แต่ก็ไม่ยาก)

คุณสามารถ refactor คลาสที่เป็นปัญหาเพื่อใช้ออบเจ็กต์ Properties เพื่อเก็บข้อมูลจริงและปล่อยให้ getter และ setter แต่ละตัวเรียก get / set ได้หรือไม่? จากนั้นคุณจะมีโครงสร้างที่เหมาะสมกับสิ่งที่คุณต้องการทำ มีแม้กระทั่งวิธีการบันทึกและโหลดในรูปแบบคีย์ - ค่า

Question 14

ทางออกที่ดีที่สุดคือการใช้ Dozer คุณต้องการสิ่งนี้ในไฟล์ mapper:

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

แค่นี้แหละ Dozer ดูแลส่วนที่เหลือ !!!

URL เอกสาร Dozer

Question 15

แน่นอนว่ามีวิธีการแปลงที่ง่ายที่สุดแน่นอน - ไม่มีการแปลงเลย!

แทนที่จะใช้ตัวแปรส่วนตัวที่กำหนดไว้ในคลาสทำให้คลาสมีเฉพาะ HashMap ที่เก็บค่าสำหรับอินสแตนซ์

จากนั้น getters และ setters ของคุณจะส่งคืนและกำหนดค่าเข้าและออกจาก HashMap และเมื่อถึงเวลาที่ต้องแปลงเป็นแผนที่ voila! - มันเป็นแผนที่อยู่แล้ว

ด้วยเวทมนตร์ AOP เล็กน้อยคุณสามารถรักษาความยืดหยุ่นที่มีอยู่ใน bean ได้โดยอนุญาตให้คุณยังคงใช้ getters และ setters เฉพาะสำหรับแต่ละชื่อค่าโดยไม่ต้องเขียน getters และ setters แต่ละตัว

Question 16

คุณสามารถใช้คุณสมบัติตัวกรองสตรีม java 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)
            );
}

Question 17

โปรเซสเซอร์คำอธิบายประกอบ JavaDude Bean ของฉันสร้างโค้ดเพื่อทำสิ่งนี้

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 {}

ข้างต้นสร้าง superclass PersonGen ที่มีเมธอด createPropertyMap () ที่สร้างแผนที่สำหรับคุณสมบัติทั้งหมดที่กำหนดโดยใช้ @Bean

(โปรดทราบว่าฉันกำลังเปลี่ยน API เล็กน้อยสำหรับเวอร์ชันถัดไป - แอตทริบิวต์คำอธิบายประกอบจะเป็น defineCreatePropertyMap = true)

Question 18

คุณควรเขียนบริการแปลงร่างทั่วไป! ใช้ generics เพื่อให้พิมพ์ฟรี (เพื่อให้คุณสามารถแปลงทุกออบเจ็กต์เป็น key => value และ back)

ฟิลด์ใดควรเป็นคีย์? รับฟิลด์นั้นจาก bean และต่อท้ายค่าอื่น ๆ ที่ไม่ใช่ชั่วคราวในแผนที่ค่า

ทางกลับค่อนข้างง่าย อ่านคีย์ (x) และเขียนคีย์ก่อนจากนั้นทุกรายการกลับไปที่อ็อบเจ็กต์ใหม่

คุณสามารถรับชื่อคุณสมบัติของถั่วด้วยถั่วapache คอมมอนส์ !

Question 19

หากคุณต้องการประสิทธิภาพจริงๆคุณสามารถไปที่เส้นทางการสร้างรหัสได้

คุณสามารถทำสิ่งนี้ต่อไปได้โดยทำการสะท้อนของคุณเองและสร้าง AspectJ ITD แบบผสมผสาน

หรือคุณสามารถใช้ Spring Roo และสร้างSpring Roo AddonAddon ส่วนเสริม Roo ของคุณจะทำสิ่งที่คล้ายกับข้างต้น แต่จะพร้อมใช้งานสำหรับทุกคนที่ใช้ Spring Roo และคุณไม่จำเป็นต้องใช้คำอธิบายประกอบแบบรันไทม์

ฉันได้ทำทั้งสองอย่างแล้ว ผู้คนเบื่อหน่ายใน Spring Roo แต่มันเป็นการสร้างโค้ดที่ครอบคลุมที่สุดสำหรับ Java

Question 20

อีกวิธีหนึ่งที่เป็นไปได้อยู่ที่นี่

BeanWrapper มีฟังก์ชันในการตั้งค่าและรับค่าคุณสมบัติ (เป็นรายบุคคลหรือจำนวนมาก) รับตัวบอกคุณสมบัติและสอบถามคุณสมบัติเพื่อพิจารณาว่าสามารถอ่านหรือเขียนได้หรือไม่

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

Question 21

หากพูดถึงโครงสร้างออบเจ็กต์แบบธรรมดาไปจนถึงการแมปรายการค่าคีย์โดยที่คีย์อาจเป็นคำอธิบายเส้นทางแบบประจากองค์ประกอบรูทของอ็อบเจ็กต์ไปจนถึงลีฟที่กำลังตรวจสอบค่อนข้างชัดเจนว่าการแปลงทรีเป็นรายการคีย์ - ค่านั้นเปรียบได้กับ วัตถุในการแมป xml แต่ละองค์ประกอบภายในเอกสาร XML มีตำแหน่งที่กำหนดและสามารถแปลงเป็นเส้นทางได้ ดังนั้นฉันจึงใช้XStreamเป็นเครื่องมือการแปลงพื้นฐานและมีเสถียรภาพและแทนที่ไดรเวอร์ลำดับชั้นและชิ้นส่วนตัวเขียนด้วยการใช้งานของตัวเอง XStream ยังมาพร้อมกับกลไกการติดตามเส้นทางพื้นฐานซึ่ง - เมื่อรวมกับอีกสองรายการ - นำไปสู่โซลูชันที่เหมาะสมกับงานอย่างเคร่งครัด

Question 22

ด้วยความช่วยเหลือของไลบรารี Jackson ฉันสามารถค้นหาคุณสมบัติคลาสทั้งหมดของประเภท String / integer / double และค่าตามลำดับในคลาส Map ( โดยไม่ต้องใช้ API การสะท้อน! )

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());
    }
}

Question 23

โดยใช้ Gson

แปลง POJO objectเป็น Json

แปลง Json เป็น Map

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

Question 24

เราสามารถใช้ไลบรารี Jackson เพื่อแปลงวัตถุ Java เป็นแผนที่ได้อย่างง่ายดาย

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

หากใช้ในโปรเจ็กต์ Android คุณสามารถเพิ่มแจ็คสันใน build.gradle ของแอพได้ดังนี้:

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);

 }

}

เอาท์พุต:

{name = XYZ, id = 1011, skills = [python, java]}