001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.model.dataformat; 018 019 import java.util.ArrayList; 020 import java.util.Arrays; 021 import java.util.HashMap; 022 import java.util.List; 023 import java.util.Map; 024 import java.util.Map.Entry; 025 026 import javax.xml.bind.annotation.XmlAccessType; 027 import javax.xml.bind.annotation.XmlAccessorType; 028 import javax.xml.bind.annotation.XmlAttribute; 029 import javax.xml.bind.annotation.XmlElement; 030 import javax.xml.bind.annotation.XmlRootElement; 031 import javax.xml.bind.annotation.XmlTransient; 032 import javax.xml.bind.annotation.XmlType; 033 import javax.xml.bind.annotation.adapters.XmlAdapter; 034 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; 035 036 import org.apache.camel.CamelContext; 037 import org.apache.camel.model.DataFormatDefinition; 038 import org.apache.camel.spi.DataFormat; 039 import org.apache.camel.spi.RouteContext; 040 import org.apache.camel.util.CamelContextHelper; 041 import org.apache.camel.util.ObjectHelper; 042 043 /** 044 * Represents the XStream XML {@link org.apache.camel.spi.DataFormat} 045 * 046 * @version 047 */ 048 @XmlRootElement(name = "xstream") 049 @XmlAccessorType(XmlAccessType.NONE) 050 public class XStreamDataFormat extends DataFormatDefinition { 051 @XmlAttribute 052 private String encoding; 053 @XmlAttribute 054 private String driver; 055 @XmlAttribute 056 private String driverRef; 057 @XmlJavaTypeAdapter(ConvertersAdapter.class) 058 @XmlElement(name = "converters") 059 private List<String> converters; 060 @XmlJavaTypeAdapter(AliasAdapter.class) 061 @XmlElement(name = "aliases") 062 private Map<String, String> aliases; 063 @XmlJavaTypeAdapter(OmitFieldsAdapter.class) 064 @XmlElement(name = "omitFields") 065 private Map<String, String[]> omitFields; 066 @XmlJavaTypeAdapter(ImplicitCollectionsAdapter.class) 067 @XmlElement(name = "implicitCollections") 068 private Map<String, String[]> implicitCollections; 069 070 public XStreamDataFormat() { 071 super("xstream"); 072 } 073 074 public XStreamDataFormat(String encoding) { 075 this(); 076 setEncoding(encoding); 077 } 078 079 public String getEncoding() { 080 return encoding; 081 } 082 083 public void setEncoding(String encoding) { 084 this.encoding = encoding; 085 } 086 087 public String getDriver() { 088 return driver; 089 } 090 091 public void setDriver(String driver) { 092 this.driver = driver; 093 } 094 095 public String getDriverRef() { 096 return driverRef; 097 } 098 099 public void setDriverRef(String driverRef) { 100 this.driverRef = driverRef; 101 } 102 103 public List<String> getConverters() { 104 return converters; 105 } 106 107 public void setConverters(List<String> converters) { 108 this.converters = converters; 109 } 110 111 public Map<String, String> getAliases() { 112 return aliases; 113 } 114 115 public void setAliases(Map<String, String> aliases) { 116 this.aliases = aliases; 117 } 118 119 public Map<String, String[]> getOmitFields() { 120 return omitFields; 121 } 122 123 public void setOmitFields(Map<String, String[]> omitFields) { 124 this.omitFields = omitFields; 125 } 126 127 public Map<String, String[]> getImplicitCollections() { 128 return implicitCollections; 129 } 130 131 public void setImplicitCollections(Map<String, String[]> implicitCollections) { 132 this.implicitCollections = implicitCollections; 133 } 134 135 @Override 136 protected DataFormat createDataFormat(RouteContext routeContext) { 137 if ("json".equals(this.driver)) { 138 setProperty(routeContext.getCamelContext(), this, "dataFormatName", "json-xstream"); 139 } 140 DataFormat answer = super.createDataFormat(routeContext); 141 // need to lookup the reference for the xstreamDriver 142 if (ObjectHelper.isNotEmpty(driverRef)) { 143 setProperty(routeContext.getCamelContext(), answer, "xstreamDriver", CamelContextHelper.mandatoryLookup(routeContext.getCamelContext(), driverRef)); 144 } 145 return answer; 146 } 147 148 @Override 149 protected void configureDataFormat(DataFormat dataFormat, CamelContext camelContext) { 150 if (encoding != null) { 151 setProperty(camelContext, dataFormat, "encoding", encoding); 152 } 153 if (this.converters != null) { 154 setProperty(camelContext, dataFormat, "converters", this.converters); 155 } 156 if (this.aliases != null) { 157 setProperty(camelContext, dataFormat, "aliases", this.aliases); 158 } 159 if (this.omitFields != null) { 160 setProperty(camelContext, dataFormat, "omitFields", this.omitFields); 161 } 162 if (this.implicitCollections != null) { 163 setProperty(camelContext, dataFormat, "implicitCollections", this.implicitCollections); 164 } 165 } 166 167 @XmlTransient 168 public static class ConvertersAdapter extends XmlAdapter<ConverterList, List<String>> { 169 @Override 170 public ConverterList marshal(List<String> v) throws Exception { 171 if (v == null) { 172 return null; 173 } 174 175 List<ConverterEntry> list = new ArrayList<ConverterEntry>(); 176 for (String str : v) { 177 ConverterEntry entry = new ConverterEntry(); 178 entry.setClsName(str); 179 list.add(entry); 180 } 181 ConverterList converterList = new ConverterList(); 182 converterList.setList(list); 183 return converterList; 184 } 185 186 @Override 187 public List<String> unmarshal(ConverterList v) throws Exception { 188 if (v == null) { 189 return null; 190 } 191 192 List<String> list = new ArrayList<String>(); 193 for (ConverterEntry entry : v.getList()) { 194 list.add(entry.getClsName()); 195 } 196 return list; 197 } 198 } 199 200 @XmlAccessorType(XmlAccessType.NONE) 201 @XmlType(name = "converterList", namespace = "http://camel.apache.org/schema/spring") 202 public static class ConverterList { 203 @XmlElement(name = "converter", namespace = "http://camel.apache.org/schema/spring") 204 private List<ConverterEntry> list; 205 206 public List<ConverterEntry> getList() { 207 return list; 208 } 209 210 public void setList(List<ConverterEntry> list) { 211 this.list = list; 212 } 213 } 214 215 @XmlAccessorType(XmlAccessType.NONE) 216 @XmlType(name = "converterEntry", namespace = "http://camel.apache.org/schema/spring") 217 public static class ConverterEntry { 218 @XmlAttribute(name = "class") 219 private String clsName; 220 221 public String getClsName() { 222 return clsName; 223 } 224 225 public void setClsName(String clsName) { 226 this.clsName = clsName; 227 } 228 } 229 230 @XmlTransient 231 public static class ImplicitCollectionsAdapter 232 extends XmlAdapter<ImplicitCollectionList, Map<String, String[]>> { 233 234 @Override 235 public ImplicitCollectionList marshal(Map<String, String[]> v) throws Exception { 236 if (v == null || v.isEmpty()) { 237 return null; 238 } 239 240 List<ImplicitCollectionEntry> list = new ArrayList<ImplicitCollectionEntry>(); 241 for (Entry<String, String[]> e : v.entrySet()) { 242 ImplicitCollectionEntry entry = new ImplicitCollectionEntry(e.getKey(), e.getValue()); 243 list.add(entry); 244 } 245 246 ImplicitCollectionList collectionList = new ImplicitCollectionList(); 247 collectionList.setList(list); 248 249 return collectionList; 250 } 251 252 @Override 253 public Map<String, String[]> unmarshal(ImplicitCollectionList v) throws Exception { 254 if (v == null) { 255 return null; 256 } 257 258 Map<String, String[]> map = new HashMap<String, String[]>(); 259 for (ImplicitCollectionEntry entry : v.getList()) { 260 map.put(entry.getClsName(), entry.getFields()); 261 } 262 return map; 263 } 264 } 265 266 @XmlAccessorType(XmlAccessType.NONE) 267 @XmlType(name = "implicitCollectionList", namespace = "http://camel.apache.org/schema/spring") 268 public static class ImplicitCollectionList { 269 @XmlElement(name = "class", namespace = "http://camel.apache.org/schema/spring") 270 private List<ImplicitCollectionEntry> list; 271 272 public List<ImplicitCollectionEntry> getList() { 273 return list; 274 } 275 276 public void setList(List<ImplicitCollectionEntry> list) { 277 this.list = list; 278 } 279 } 280 281 @XmlAccessorType(XmlAccessType.NONE) 282 @XmlType(name = "implicitCollectionEntry", namespace = "http://camel.apache.org/schema/spring") 283 public static class ImplicitCollectionEntry { 284 @XmlAttribute(name = "name") 285 private String clsName; 286 287 @XmlElement(name = "field", namespace = "http://camel.apache.org/schema/spring") 288 private String[] fields; 289 290 public ImplicitCollectionEntry() { 291 } 292 293 public ImplicitCollectionEntry(String clsName, String[] fields) { 294 this.clsName = clsName; 295 this.fields = fields; 296 } 297 298 public String getClsName() { 299 return clsName; 300 } 301 302 public void setClsName(String clsName) { 303 this.clsName = clsName; 304 } 305 306 public String[] getFields() { 307 return fields; 308 } 309 310 public void setFields(String[] fields) { 311 this.fields = fields; 312 } 313 314 @Override 315 public String toString() { 316 return "Alias[ImplicitCollection=" + clsName + ", fields=" + Arrays.asList(this.fields) + "]"; 317 } 318 } 319 320 @XmlTransient 321 public static class AliasAdapter extends XmlAdapter<AliasList, Map<String, String>> { 322 323 @Override 324 public AliasList marshal(Map<String, String> value) throws Exception { 325 if (value == null || value.isEmpty()) { 326 return null; 327 } 328 329 List<AliasEntry> ret = new ArrayList<AliasEntry>(value.size()); 330 for (Map.Entry<String, String> entry : value.entrySet()) { 331 ret.add(new AliasEntry(entry.getKey(), entry.getValue())); 332 } 333 AliasList jaxbMap = new AliasList(); 334 jaxbMap.setList(ret); 335 return jaxbMap; 336 } 337 338 @Override 339 public Map<String, String> unmarshal(AliasList value) throws Exception { 340 if (value == null || value.getList() == null || value.getList().isEmpty()) { 341 return null; 342 } 343 344 Map<String, String> answer = new HashMap<String, String>(); 345 for (AliasEntry alias : value.getList()) { 346 answer.put(alias.getName(), alias.getClsName()); 347 } 348 return answer; 349 } 350 } 351 352 @XmlAccessorType(XmlAccessType.NONE) 353 @XmlType(name = "aliasList", namespace = "http://camel.apache.org/schema/spring") 354 public static class AliasList { 355 @XmlElement(name = "alias", namespace = "http://camel.apache.org/schema/spring") 356 private List<AliasEntry> list; 357 358 public List<AliasEntry> getList() { 359 return list; 360 } 361 362 public void setList(List<AliasEntry> list) { 363 this.list = list; 364 } 365 } 366 367 @XmlAccessorType(XmlAccessType.NONE) 368 @XmlType(name = "aliasEntry", namespace = "http://camel.apache.org/schema/spring") 369 public static class AliasEntry { 370 371 @XmlAttribute 372 private String name; 373 374 @XmlAttribute(name = "class") 375 private String clsName; 376 377 public AliasEntry() { 378 } 379 380 public AliasEntry(String key, String clsName) { 381 this.name = key; 382 this.clsName = clsName; 383 } 384 385 public String getName() { 386 return name; 387 } 388 389 public void setName(String name) { 390 this.name = name; 391 } 392 393 public String getClsName() { 394 return clsName; 395 } 396 397 public void setClsName(String clsName) { 398 this.clsName = clsName; 399 } 400 401 @Override 402 public String toString() { 403 return "Alias[name=" + name + ", class=" + clsName + "]"; 404 } 405 } 406 407 @XmlTransient 408 public static class OmitFieldsAdapter 409 extends XmlAdapter<OmitFieldList, Map<String, String[]>> { 410 411 @Override 412 public OmitFieldList marshal(Map<String, String[]> v) throws Exception { 413 if (v == null || v.isEmpty()) { 414 return null; 415 } 416 417 List<OmitFieldEntry> list = new ArrayList<OmitFieldEntry>(); 418 for (Entry<String, String[]> e : v.entrySet()) { 419 OmitFieldEntry entry = new OmitFieldEntry(e.getKey(), e.getValue()); 420 list.add(entry); 421 } 422 423 OmitFieldList collectionList = new OmitFieldList(); 424 collectionList.setList(list); 425 426 return collectionList; 427 } 428 429 @Override 430 public Map<String, String[]> unmarshal(OmitFieldList v) throws Exception { 431 if (v == null || v.getList() == null || v.getList().isEmpty()) { 432 return null; 433 } 434 435 Map<String, String[]> map = new HashMap<String, String[]>(); 436 for (OmitFieldEntry entry : v.getList()) { 437 map.put(entry.getClsName(), entry.getFields()); 438 } 439 return map; 440 } 441 } 442 443 @XmlAccessorType(XmlAccessType.NONE) 444 @XmlType(name = "omitFieldList", namespace = "http://camel.apache.org/schema/spring") 445 public static class OmitFieldList { 446 @XmlElement(name = "omitField", namespace = "http://camel.apache.org/schema/spring") 447 private List<OmitFieldEntry> list; 448 449 public List<OmitFieldEntry> getList() { 450 return list; 451 } 452 453 public void setList(List<OmitFieldEntry> list) { 454 this.list = list; 455 } 456 } 457 458 @XmlAccessorType(XmlAccessType.NONE) 459 @XmlType(name = "omitFieldEntry", namespace = "http://camel.apache.org/schema/spring") 460 public static class OmitFieldEntry { 461 462 @XmlAttribute(name = "class") 463 private String clsName; 464 465 @XmlElement(name = "field", namespace = "http://camel.apache.org/schema/spring") 466 private String[] fields; 467 468 public OmitFieldEntry() { 469 } 470 471 public OmitFieldEntry(String clsName, String[] fields) { 472 this.clsName = clsName; 473 this.fields = fields; 474 } 475 476 public String getClsName() { 477 return clsName; 478 } 479 480 public void setClsName(String clsName) { 481 this.clsName = clsName; 482 } 483 484 public String[] getFields() { 485 return fields; 486 } 487 488 public void setFields(String[] fields) { 489 this.fields = fields; 490 } 491 492 @Override 493 public String toString() { 494 return "OmitField[" + clsName + ", fields=" + Arrays.asList(this.fields) + "]"; 495 } 496 } 497 498 }