Bir Java nesnesini (bean) anahtar-değer çiftlerine (ve tersi) nasıl dönüştürebilirim?

Sadece bazı getXXX ve setXXX özelliklerine sahip çok basit bir java nesnem olduğunu varsayalım. Bu nesne, temelde bir kayıt veya tür açısından güvenli (ve performans gösteren) bir harita gibi yalnızca değerleri işlemek için kullanılır. Sık sık bu nesneyi anahtar değer çiftlerine (dizeler veya kasa tipi) dönüştürmem veya anahtar değer çiftlerinden bu nesneye dönüştürmem gerekir.

Bu dönüşümü yapmak için yansıtma veya manuel olarak kod yazma dışında, bunu başarmanın en iyi yolu nedir?

Bir örnek, bu nesneyi ObjectMessage türünü kullanmadan jms üzerinden göndermek (veya gelen bir mesajı doğru türdeki bir nesneye dönüştürmek) olabilir.

Her zaman apache commons beanutils vardır, ancak elbette başlık altında

Pek çok potansiyel çözüm var, ancak bir tane daha ekleyelim. Kullanım Jackson (JSON işleme lib) gibi "json-az" dönüştürme yapmak için:

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

( bu blog girişinde daha fazla örnek var)

Temel olarak herhangi bir uyumlu türü dönüştürebilirsiniz: uyumlu, türden JSON'a ve bu JSON'dan sonuç türüne dönüştürme yaptıysanız, girişlerin eşleşeceği anlamına gelir (uygun şekilde yapılandırılırsa, tanınmayanları da yok sayabilir).

Haritalar, Listeler, diziler, ilkeller, fasulye benzeri POJO'lar dahil olmak üzere beklenebilecek durumlarda iyi çalışır.

Kod oluşturma, düşünebildiğim tek başka yol olabilir. Şahsen, genel olarak yeniden kullanılabilir bir yansıtma çözümüne sahiptim (kodun bu kısmı kesinlikle performans açısından kritik değilse). JMS kullanmak kulağa aşırılık gibi geliyor (ek bağımlılık ve bunun anlamı bile bu değil). Ayrıca, muhtemelen kaputun altında da yansıma kullanıyor.

Bu, bir Java nesnesini Haritaya dönüştürmek için bir yöntemdir

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

Bu nasıl adlandırılır

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

Muhtemelen partiye geç kalmıştır. Jackson'ı kullanabilir ve bunu bir Özellikler nesnesine dönüştürebilirsiniz. Bu, Yuvalanmış sınıflar için ve for abc = değerindeki anahtarı istiyorsanız uygundur.

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

Eğer bir sonek istiyorsanız, o zaman sadece

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

bu bağımlılığı eklemeniz gerekiyor

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

Java 8 ile şunu deneyebilirsiniz:

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

JSON , örneğin XStream + Jettison kullanan, anahtar-değer çiftlerine sahip basit bir metin formatıdır. Örneğin, diğer platformlarla / dillerle Java nesne değişimi için Apache ActiveMQ JMS mesaj aracısı tarafından desteklenir.

Yansıma ve Groovy kullanarak:

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

Juffrou-reflektörün BeanWrapper'ını kullanın . Çok başarılı.

Bir fasulyeyi haritaya nasıl dönüştürebileceğiniz aşağıda açıklanmıştır:

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'yu kendim geliştirdim. Açık kaynaktır, bu yüzden onu kullanmakta ve değiştirmekte özgürsünüz. Ve bununla ilgili herhangi bir sorunuz varsa, cevap vermekten çok mutlu olacağım.

Şerefe

Carlos

Spring kullanılırken, Spring Integration nesnesi-harita-trafosu da kullanılabilir. Spring'i bağımlılık olarak eklemeye muhtemelen sadece bunun için değmez.

Dokümantasyon için http://docs.spring.io/spring-integration/docs/4.0.4.RELEASE/reference/html/messaging-transformation-chapter.html adresinde " Nesneden Haritaya Dönüştürücü" araması yapın.

Esasen, girdi olarak verilen nesneden erişilebilen tüm nesne grafiğini dolaşır ve nesneler üzerindeki tüm ilkel tip / String alanlarından bir harita üretir. Aşağıdakilerden biri çıktı verecek şekilde yapılandırılabilir:

• düz bir harita: {rootObject.someField = Joe, rootObject.leafObject.someField = Jane} veya
• yapılandırılmış bir harita: {someField = Joe, leafObject = {someField = Jane}}.

İşte kendi sayfalarından bir örnek:

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
}

Çıktı şu şekilde olacaktır:

{person.name = George, person.child.name = Jenna, person.child.nickNames [0] = Bimbo. . . vb}

Ters transformatör de mevcuttur.

Joda çerçevesini kullanabilirsiniz:

http://joda.sourceforge.net/

ve JodaProperties'den yararlanın. Bu, fasulyeleri belirli bir şekilde oluşturmanızı ve belirli bir arayüz uygulamanızı şart koşar. Bununla birlikte, belirli bir sınıftan bir özellik haritasını yansıtma yapmadan döndürmenize izin verir. Örnek kod burada:

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

Her alıcıya ve ayarlayıcıya çağrıları kodlamak istemiyorsanız, yansıtma bu yöntemleri çağırmanın tek yoludur (ancak zor değildir).

Gerçek verileri tutmak için bir Properties nesnesini kullanmak için söz konusu sınıfı yeniden düzenleyebilir ve her alıcı ve ayarlayıcının üzerinde get / set çağırmasına izin verebilir misiniz? O zaman yapmak istediklerinize çok uygun bir yapıya sahip olursunuz. Bunları kaydetme ve anahtar-değer biçiminde yükleme yöntemleri bile vardır.

En iyi çözüm Dozer kullanmaktır. Eşleştirici dosyasında buna benzer bir şeye ihtiyacınız var:

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

İşte bu, Dozer gerisini halleder !!!

Dozer Belgeleri URL'si

Elbette mümkün olan en basit dönüştürme yöntemi var - hiç dönüştürme yok!

sınıfta tanımlanan özel değişkenleri kullanmak yerine, sınıfın yalnızca örnek için değerleri depolayan bir HashMap içermesini sağlayın.

Ardından alıcılarınız ve ayarlayıcılarınız HashMap içine ve dışına değerleri geri döndürür ve ayarlar ve onu bir haritaya dönüştürme zamanı geldiğinde, işte! - bu zaten bir harita.

Biraz AOP sihirbazlığıyla, tek tek alıcıları ve ayarlayıcıları gerçekten yazmak zorunda kalmadan, her değer adına özgü alıcıları ve ayarlayıcıları kullanmaya devam etmenize izin vererek, bir çekirdeğin doğasında bulunan esnekliği bile koruyabilirsiniz.

Java 8 stream filtre toplayıcı özelliklerini kullanabilirsiniz,

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

JavaDude Bean Ek Açıklama İşlemcim bunu yapmak için kod üretir.

http://javadude.googlecode.com

Örneğin:

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

Yukarıdakiler, @Bean kullanılarak tanımlanan tüm özellikler için bir Harita oluşturan createPropertyMap () yöntemini içeren süper sınıf PersonGen'i oluşturur.

(Bir sonraki sürüm için API'yi biraz değiştirdiğimi unutmayın - ek açıklama özelliği defineCreatePropertyMap = true olacaktır)

Genel bir dönüşüm hizmeti yazmalısınız! Yazıyı serbest tutmak için jenerikler kullanın (böylece her nesneyi anahtar => değere ve geri dönüştürebilirsiniz).

Anahtar hangi alan olmalıdır? Bu alanı çekirdekten alın ve diğer geçici olmayan değeri bir değer haritasına ekleyin.

Dönüş yolu oldukça kolay. (X) anahtarını okuyun ve önce anahtarı ardından her liste girişini yeni bir nesneye geri yazın.

Bir fasulyenin özellik adlarını apache commons beanutils ile alabilirsiniz !

Gerçekten performans istiyorsanız, kod oluşturma yoluna gidebilirsiniz.

Bunu, kendi düşüncenizi oluşturarak ve AspectJ ITD'de bir karışım oluşturarak yapabilirsiniz.

Veya Spring Roo'yu kullanabilir ve Spring Roo Addon yapabilirsiniz . Roo eklentiniz yukarıdakine benzer bir şey yapacak ancak Spring Roo kullanan herkes tarafından kullanılabilecek ve Runtime Ek Açıklamalarını kullanmak zorunda kalmayacaksınız.

Ben ikisini de yaptım. İnsanlar Spring Roo ile dalga geçiyor ama bu gerçekten Java için en kapsamlı kod oluşturma.

Bir başka olası yol da burasıdır.

BeanWrapper, özellik değerlerini (tek tek veya toplu olarak) ayarlama ve alma, özellik tanımlayıcılarını alma ve bunların okunabilir veya yazılabilir olup olmadığını belirlemek için özellikleri sorgulama işlevi sunar.

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

Anahtar değer listesi eşlemesine basit bir nesne ağacı gelirse, burada anahtar, nesnenin kök öğesinden incelenmekte olan yaprağa kadar noktalı bir yol açıklaması olabilir, bir anahtar-değer listesine ağaç dönüşümünün bir anahtar-değer listesine dönüştürülmesinin bir xml eşleme nesnesi. XML belgesindeki her öğenin tanımlı bir konumu vardır ve bir yola dönüştürülebilir. Bu nedenle, XStream'i temel ve kararlı bir dönüştürme aracı olarak aldım ve hiyerarşik sürücü ve yazıcı parçalarını kendi uygulamayla değiştirdim. XStream ayrıca - diğer ikisiyle birleştirildiğinde - kesinlikle göreve uygun bir çözüme götüren temel bir yol izleme mekanizmasıyla birlikte gelir.

Jackson kütüphanesinin yardımıyla String / integer / double türündeki tüm sınıf özelliklerini ve bir Map sınıfındaki ilgili değerleri bulabildim. ( yansımalar api kullanmadan! )

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

Gson kullanarak,

1. POJO dosyasını objectJson biçimine dönüştür

2. Json'u Haritaya Dönüştür

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

Bir Java nesnesini kolayca bir Haritaya dönüştürmek için Jackson kitaplığını kullanabiliriz.

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

Bir Android projesinde kullanıyorsanız, uygulamanızın build.gradle dosyasına aşağıdaki gibi jackson ekleyebilirsiniz:

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'

Örnek Uygulama

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

 }

}

Çıktı:

{ad = XYZ, id = 1011, beceriler = [python, java]}