Javaオブジェクト（bean）をキーと値のペアに（またはその逆に）変換する方法は？

いくつかのgetXXXおよびsetXXXプロパティのみを持つ非常に単純なJavaオブジェクトがあるとします。このオブジェクトは、値を処理するためにのみ使用されます。基本的には、レコードまたはタイプセーフな（そしてパフォーマンスの高い）マップです。このオブジェクトをキー値ペア（文字列またはタイプセーフ）に変換するか、キー値ペアからこのオブジェクトに変換する必要があることがよくあります。

この変換を行うためにリフレクションまたは手動でコードを書く以外に、これを達成するための最良の方法は何ですか？

たとえば、ObjectMessageタイプを使用せずに（または受信メッセージを適切な種類のオブジェクトに変換して）、jmsを介してこのオブジェクトを送信する場合があります。

apache commons beanutilsは常に存在しますが、もちろん内部でリフレクションを使用します

解決策はたくさんありますが、もう1つ追加しましょう。ジャクソン（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から結果のタイプに変換した場合、エントリが一致することを意味します（適切に構成されていれば、認識されないものも無視できます）。

マップ、リスト、配列、プリミティブ、BeanのようなPOJOなど、予想されるケースに適しています。

コード生成は、私が考えることができる他の唯一の方法でしょう。個人的には、一般的に再利用可能なリフレクションソリューションを使用します（コードのその部分が絶対にパフォーマンスが重要でない限り）。JMSの使用はやり過ぎのように聞こえます（追加の依存関係であり、それが意図されていることすらありません）。その上、それはおそらくフードの下で同様に反射を使用します。

これは、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);

おそらくパーティーに遅れる。Jacksonを使用して、それをPropertiesオブジェクトに変換できます。これは、ネストされたクラスや、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>

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

たとえばXStream + Jettisonを使用するJSONは、キーと値のペアを持つ単純なテキスト形式です。たとえば、他のプラットフォームや言語とのJavaオブジェクト交換のためのApache ActiveMQ JMSメッセージブローカーによってサポートされています。

単にリフレクションと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;
}

使用juffrouは、反映のBeanWrapperを。とても高性能です。

Beanをマップに変換する方法は次のとおりです。

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

私はジュフロを自分で開発しました。これはオープンソースなので、自由に使用して変更できます。また、ご不明な点がございましたら、お気軽にお問い合わせください。

乾杯

カルロス

Springを使用する場合は、Spring Integrationのオブジェクトからマップへの変換を使用することもできます。これだけの依存関係としてSpringを追加する価値はないでしょう。

ドキュメントについては、http：//docs.spring.io/spring-integration/docs/4.0.4.RELEASE/reference/html/messaging-transformation-chapter.htmlで「Object-to-Map Transformer」を検索してください

基本的に、入力として与えられたオブジェクトから到達可能なオブジェクトグラフ全体を横断し、オブジェクトのすべてのプリミティブ型/文字列フィールドからマップを生成します。次のいずれかを出力するように構成できます。

• フラットマップ：{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] =ヤリマン。。。等}

逆変圧器も利用できます。

Jodaフレームワークを使用できます。

http://joda.sourceforge.net/

JodaPropertiesを利用します。ただし、これは特定の方法でBeanを作成し、特定のインターフェースを実装することを規定しています。ただし、リフレクションなしで特定のクラスからプロパティマップを返すことができます。サンプルコードはこちらです：

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

各ゲッターとセッターへの呼び出しをハードコーディングしたくない場合は、リフレクションがこれらのメソッドを呼び出す唯一の方法です（ただし、難しくはありません）。

問題のクラスをリファクタリングして、Propertiesオブジェクトを使用して実際のデータを保持し、各ゲッターとセッターにget / setを呼び出させることはできますか？そして、あなたはあなたがしたいことによく合った構造を持っています。これらをKey-Valueフォームに保存してロードする方法もあります。

最善の解決策はDozerを使用することです。マッパーファイルに次のようなものが必要です。

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

そして、それだけです。残りはDozerが処理します!!!

DozerドキュメントURL

もちろん、可能な限り最も単純な変換方法があります-変​​換はまったくありません！

クラスで定義されたプライベート変数を使用する代わりに、インスタンスの値を格納するHashMapのみをクラスに含めるようにします。

次に、ゲッターとセッターがHashMapに値を返したり、HashMapから値を設定したりします。そして、それをマップに変換するときが来たら、出来上がりです！-それはすでに地図です。

AOPウィザードを少し使用すると、実際に個々のゲッターとセッターを作成しなくても、各値の名前に固有のゲッターとセッターを引き続き使用できるため、Beanに固有の柔軟性を維持することもできます。

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

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

上記は、@ Beanを使用して定義されたすべてのプロパティのマップを生成するcreatePropertyMap（）メソッドを含むスーパークラスPersonGenを生成します。

（次のバージョンではAPIを少し変更していることに注意してください-アノテーション属性はdefineCreatePropertyMap = trueになります）

一般的な変換サービスを作成する必要があります！ジェネリックを使用して型を空けておきます（すべてのオブジェクトをkey => valueに変換して戻すことができます）。

キーとなるフィールドは何ですか？Beanからそのフィールドを取得し、値マップに他の非一時的な値を追加します。

戻る方法はかなり簡単です。key（x）を読み取り、最初にキーを書き込んでから、すべてのリストエントリを新しいオブジェクトに戻します。

Apache Commons beanutilsを使用して、Beanのプロパティ名を取得できます。

本当にパフォーマンスが必要な場合は、コード生成ルートに進むことができます。

独自のリフレクションを行い、ミックスインのAspectJ ITDを構築することで、これを自分で行うことができます。

または、Spring Rooを使用してSpring Rooアドオンを作成することもできます。Rooアドオンは上記と同様の機能を果たしますが、Spring Rooを使用するすべてのユーザーが利用でき、ランタイムアノテーションを使用する必要はありません。

私は両方を行いました。人々はSpring Rooに熱狂していますが、それは本当にJavaの最も包括的なコード生成です。

もう1つの可能な方法はこちらです。

BeanWrapperは、プロパティ値の設定と取得（個別または一括）、プロパティ記述子の取得、およびプロパティのクエリを実行して、それらが読み取り可能か書き込み可能かを判断する機能を提供します。

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

単純なオブジェクトツリーからキー値リストへのマッピングの場合、キーはオブジェクトのルート要素から検査対象の葉へのドットパスの説明である可能性があります。キー値リストへのツリー変換は、オブジェクトからXMLへのマッピング。XMLドキュメント内の各要素には位置が定義されており、パスに変換できます。そのため、XStreamを基本的で安定した変換ツールとして、階層的なドライバーとライターの部分を独自の実装に置き換えました。XStreamには、他の2つと組み合わせると、厳密にタスクに適したソリューションにつながる基本的なパス追跡メカニズムも付属しています。

ジャクソンライブラリーの助けを借りて、タイプ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());
    }
}

Gsonを使用することにより、

1. POJO objectをJsonに変換する

2. Jsonをマップに変換

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

Jacksonライブラリーを使用して、JavaオブジェクトをMapに簡単に変換できます。

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

Androidプロジェクトで使用する場合は、次のようにアプリのbuild.gradleにjacksonを追加できます。

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