XMLDeserializer.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils.serialization;

  24. import java.io.ByteArrayOutputStream;
  25. import java.io.InputStream;
  26. import java.io.Reader;
  27. import java.io.StringWriter;
  28. import java.lang.reflect.Method;
  29. import java.util.ArrayList;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.Set;

  34. import org.openspcoop2.utils.CopyCharStream;
  35. import org.openspcoop2.utils.CopyStream;
  36. import org.openspcoop2.utils.UtilsException;
  37. import org.openspcoop2.utils.resources.ClassLoaderUtilities;

  39. import net.sf.ezmorph.MorpherRegistry;
  40. import net.sf.json.JSONArray;
  41. import net.sf.json.JSONObject;
  42. import net.sf.json.JsonConfig;
  43. import net.sf.json.util.JSONUtils;

  45. /** 
  46.  * Contiene utility per effettuare la de-serializzazione di un oggetto
  47.  *
  48.  * @author Poli Andrea (apoli@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  */

  53. public class XMLDeserializer implements IDeserializer{

  55.     private net.sf.json.xml.XMLSerializer xmlSerializer;
  56.     private JsonConfig jsonConfig;
  57.     private List<String> morpherPackage = new ArrayList<>();
  58.     private boolean throwExceptionMorpherFailed = true;
  59.     
  60.     public XMLDeserializer(){
  61.         this(new SerializationConfig());
  62.     }
  63.     public XMLDeserializer(SerializationConfig config) {
  64.         this.xmlSerializer = new net.sf.json.xml.XMLSerializer();
  65.         JsonConfig jsonConfig = new JsonConfig();
  66.         if(config.getExcludes()!=null){
  67.             //jsonConfig.setExcludes(excludes); non funziona l'exclude durante la deserializzazione, uso un filtro
  68.             jsonConfig.setJavaPropertyFilter(new ExclusionPropertyFilter(config.getExcludes()));
  69.         } 
  70.         this.jsonConfig = jsonConfig;
  71.         this.addMorpherPackage("org.openspcoop2");
  72.     }
  73.     
  74.     public void addMorpherPackage(String p){
  75.         this.morpherPackage.add(p);
  76.     }
  77.     
  78.     public boolean isThrowExceptionMorpherFailed() {
  79.         return this.throwExceptionMorpherFailed;
  80.     }
  81.     public void setThrowExceptionMorpherFailed(boolean throwExceptionMorpherFailed) {
  82.         this.throwExceptionMorpherFailed = throwExceptionMorpherFailed;
  83.     }
  84.     
  85.     
  86.     @Override
  87.     public Object getObject(String s, Class<?> classType) throws IOException{
  88.         return getObject(s, classType, null);
  89.     }
  90.     public Object getListObject(String s, Class<?> listType, Class<?> elementsTypes) throws IOException{
  91.         Object o = getObject(s, listType, elementsTypes);
  92.         if( !(o instanceof List) ){
  93.             throw new IOException("Object de-serializzato di tipo non java.util.List: "+o.getClass().getName());
  94.         }
  95.         return o;
  96.     }
  97.     public Object getSetObject(String s, Class<?> setType, Class<?> elementsTypes) throws IOException{
  98.         Object o = getObject(s, setType, elementsTypes);
  99.         if( !(o instanceof Set) ){
  100.             throw new IOException("Object de-serializzato di tipo non java.util.Set: "+o.getClass().getName());
  101.         }
  102.         return o;
  103.     }
  104.     private Object getObject(String s, Class<?> classType, Class<?> elementsTypes ) throws IOException{
  105.         try{
  106.             return readObject_engine(s, classType, elementsTypes);  
  107.         }catch(Exception e){
  108.             throw new IOException("Trasformazione in oggetto non riuscita: "+e.getMessage(),e);
  109.         }
  110.     }
  111.     
  112.     
  113.     
  114.     @Override
  115.     public Object readObject(InputStream is, Class<?> classType) throws IOException{
  116.         return readObject(is, classType, null);
  117.     }
  118.     public Object readListObject(InputStream is, Class<?> listType, Class<?> elementsTypes) throws IOException{
  119.         Object o = readObject(is, listType, elementsTypes);
  120.         if( !(o instanceof List) ){
  121.             throw new IOException("Object de-serializzato di tipo non java.util.List: "+o.getClass().getName());
  122.         }
  123.         return o;
  124.     }
  125.     public Object readSetObject(InputStream is, Class<?> setType, Class<?> elementsTypes) throws IOException{
  126.         Object o = readObject(is, setType, elementsTypes);
  127.         if( !(o instanceof Set) ){
  128.             throw new IOException("Object de-serializzato di tipo non java.util.Set: "+o.getClass().getName());
  129.         }
  130.         return o;
  131.     }
  132.     private Object readObject(InputStream is, Class<?> classType, Class<?> elementsTypes) throws IOException{
  133.         try{
  134.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  135. //          byte [] reads = new byte[Utilities.DIMENSIONE_BUFFER];
  136. //          int letti = 0;
  137. //          while( (letti=is.read(reads)) != -1 ){
  138. //              bout.write(reads, 0, letti);
  139. //          }
  140.             CopyStream.copy(is, bout);
  141.             bout.flush();
  142.             bout.close();
  143.             
  144.             return readObject_engine(bout.toString(), classType, elementsTypes);    
  145.             
  146.         }catch(Exception e){
  147.             throw new IOException("Trasformazione in oggetto non riuscita: "+e.getMessage(),e);
  148.         }
  149.     }
  150.     
  151.     
  152.     
  153.     @Override
  154.     public Object readObject(Reader reader, Class<?> classType) throws IOException{
  155.         return readObject(reader, classType, null);
  156.     }
  157.     public Object readListObject(Reader reader, Class<?> listType, Class<?> elementsTypes) throws IOException{
  158.         Object o = readObject(reader, listType, elementsTypes);
  159.         if( !(o instanceof List) ){
  160.             throw new IOException("Object de-serializzato di tipo non java.util.List: "+o.getClass().getName());
  161.         }
  162.         return o;
  163.     }
  164.     public Object readSetObject(Reader reader, Class<?> setType, Class<?> elementsTypes) throws IOException{
  165.         Object o = readObject(reader, setType, elementsTypes);
  166.         if( !(o instanceof Set) ){
  167.             throw new IOException("Object de-serializzato di tipo non java.util.Set: "+o.getClass().getName());
  168.         }
  169.         return o;
  170.     }
  171.     private Object readObject(Reader reader, Class<?> classType, Class<?> elementsTypes) throws IOException{
  172.         try{
  173. //          char [] reads = new char[Utilities.DIMENSIONE_BUFFER];
  174. //          int letti = 0;
  175. //          StringBuilder bf = new StringBuilder();
  176. //          while( (letti=reader.read(reads)) != -1 ){
  177. //              bf.append(reads, 0, letti);
  178. //          }
  179.             StringWriter writer = new StringWriter();
  180.             CopyCharStream.copy(reader, writer);
  181.                         
  182.             return readObject_engine(writer.toString(), classType, elementsTypes);  
  183.             
  184.         }catch(Exception e){
  185.             throw new IOException("Trasformazione in oggetto non riuscita: "+e.getMessage(),e);
  186.         }
  187.     }

  189.     
  190.     
  191.     private Object readObject_engine(String object,Class<?> classType, Class<?> elementsTypes) throws Exception{
  192.         
  193.         boolean list = false;
  194.         try{
  195.             classType.asSubclass(List.class);
  196.             list = true;
  197.         }catch(ClassCastException cc){}
  198.         
  199.         boolean set = false;
  200.         try{
  201.             classType.asSubclass(Set.class);
  202.             set = true;
  203.         }catch(ClassCastException cc){}
  204.         
  205.         //System.out.println("CLASS: "+classType.getName() +" ENUM["+classType.isEnum()+"] ARRAY["+classType.isArray()+"] LISTCAST["+list+"] SETCAST["+set+"]");
  206.         
  207.         if(classType.isEnum()){
  208.             
  209.             Object oResult = this.xmlSerializer.read( object );
  210.             Object en = null;
  211.             if(oResult instanceof JSONObject){
  212.                 JSONObject jsonObject = (JSONObject)  oResult;
  213.                 en = jsonObject.get(jsonObject.keys().next());
  214.             }else{
  215.                 JSONArray jsonArray = (JSONArray)  oResult;
  216.                 en = jsonArray.toArray()[0];
  217.             }
  218.             //System.out.println("TIPO ["+en.getClass().getName()+"]");
  219.             Object [] o = classType.getEnumConstants();
  220.             Class<?> enumeration = o[0].getClass();
  221.             //System.out.println("OO ["+enumeration+"]");
  222.             Method method = enumeration.getMethod("valueOf", String.class);
  223.             Object value = method.invoke(enumeration, en);
  224.             return value;
  225.         }
  226.         
  227.         else if(classType.isArray()){

  229.             Object oResult = this.xmlSerializer.read( object );
  230.             if(oResult instanceof JSONObject){
  231.                 JSONObject jsonObject = (JSONObject)  oResult;
  232.                 Iterator<?> it = jsonObject.keys();
  233.                 Object[] array = new Object[jsonObject.values().size()];
  234.                 int i=0;
  235.                 while(it.hasNext()){
  236.                     Object key = it.next();
  237.                     Object value = jsonObject.get(key);
  238.                     JSONObject json = (JSONObject) value;
  239.                     array[i] =  fromJSONObjectToOriginalObject(classType.getComponentType(), json);
  240.                     i++;
  241.                 }
  242.                 return array;
  243.             }else{
  244.                 JSONArray jsonArray = (JSONArray)  oResult;
  245.                 Object[] oarray = jsonArray.toArray();
  246.                 Object[] array = new Object[oarray.length];
  247.                 for(int i=0; i<oarray.length;i++){
  248.                     JSONObject json = (JSONObject) oarray[i];
  249.                     array[i] =  fromJSONObjectToOriginalObject(classType.getComponentType(), json);
  250.                 }
  251.                 return array;
  252.             }

  254.         }
  255.         
  256.         else if(list){
  257.             
  258.             if(elementsTypes==null){
  259.                 throw new Exception("elementsTypes non definito, e' obbligatorio per il tipo che si desidera de-serializzare: "+classType.getName());
  260.             }
  261.             
  262.             Object oResult = this.xmlSerializer.read( object );
  263.             if(oResult instanceof JSONObject){
  264.                 JSONObject jsonObject = (JSONObject)  oResult;
  265.                 Iterator<?> it = jsonObject.keys();
  266.                 @SuppressWarnings("unchecked")
  267.                 List<Object> listReturn = (List<Object>) ClassLoaderUtilities.newInstance(classType);       
  268.                 while(it.hasNext()){
  269.                     Object key = it.next();
  270.                     Object value = jsonObject.get(key);
  271.                     JSONObject json = (JSONObject) value;
  272.                     Object o =  fromJSONObjectToOriginalObject(elementsTypes, json);
  273.                     listReturn.add(o);
  274.                 }
  275.                 return listReturn;
  276.             }else{
  277.                 JSONArray jsonArray = (JSONArray)  oResult;
  278.                 Object[] oarray = jsonArray.toArray();
  279.                 @SuppressWarnings("unchecked")
  280.                 List<Object> listReturn = (List<Object>) ClassLoaderUtilities.newInstance(classType);       
  281.                 for(int i=0; i<oarray.length;i++){
  282.                     JSONObject json = (JSONObject) oarray[i];
  283.                     Object o =  fromJSONObjectToOriginalObject(elementsTypes, json);
  284.                     listReturn.add(o);
  285.                 }
  286.                 return listReturn;
  287.             }
  288.             
  289.         }
  290.         
  291.         else if(set){
  292.             
  293.             if(elementsTypes==null){
  294.                 throw new Exception("elementsTypes non definito, e' obbligatorio per il tipo che si desidera de-serializzare: "+classType.getName());
  295.             }
  296.             
  297.             Object oResult = this.xmlSerializer.read( object );
  298.             if(oResult instanceof JSONObject){
  299.                 JSONObject jsonObject = (JSONObject)  oResult;
  300.                 Iterator<?> it = jsonObject.keys();
  301.                 @SuppressWarnings("unchecked")
  302.                 Set<Object> setReturn = (Set<Object>) ClassLoaderUtilities.newInstance(classType);      
  303.                 while(it.hasNext()){
  304.                     Object key = it.next();
  305.                     Object value = jsonObject.get(key);
  306.                     JSONObject json = (JSONObject) value;
  307.                     Object o =  fromJSONObjectToOriginalObject(elementsTypes, json);
  308.                     setReturn.add(o);
  309.                 }
  310.                 return setReturn;
  311.             }else{
  312.                 JSONArray jsonArray = (JSONArray)  oResult;
  313.                 Object[] oarray = jsonArray.toArray();
  314.                 @SuppressWarnings("unchecked")
  315.                 Set<Object> setReturn = (Set<Object>) ClassLoaderUtilities.newInstance(classType);          
  316.                 for(int i=0; i<oarray.length;i++){
  317.                     JSONObject json = (JSONObject) oarray[i];
  318.                     Object o =  fromJSONObjectToOriginalObject(elementsTypes, json);
  319.                     setReturn.add(o);
  320.                 }
  321.                 return setReturn;
  322.             }
  323.             
  324.         }
  325.         
  326.         else{
  327.             JSONObject jsonObject = (JSONObject) this.xmlSerializer.read( object );
  328.             return fromJSONObjectToOriginalObject(classType, jsonObject);
  329.         }
  330.     }
  331.     
  332.     private Object fromJSONObjectToOriginalObject(Class<?> classType, JSONObject jsonObject) throws UtilsException{
  333.         this.jsonConfig.setRootClass(classType);
  334.         
  335.         MorpherRegistry morpherRegistry = JSONUtils.getMorpherRegistry();
  336.         org.openspcoop2.utils.serialization.Utilities.registerMorpher(classType, morpherRegistry, new ArrayList<>(), this.morpherPackage);
  337.         
  338.         Object o = JSONObject.toBean( jsonObject, this.jsonConfig );

  340.         org.openspcoop2.utils.serialization.Utilities.morpher(o, morpherRegistry, this.morpherPackage, this.throwExceptionMorpherFailed);
  341.         
  342.         return o;
  343.     }
  344. }
Created with JaCoCo 0.8.8.202204050719