/** * @param writer * @param includeHistory * @param session * @throws DataAccessException * @throws HibernateException */ private void writeObjects( final Writer writer, final boolean includeHistory, final Session session, final boolean preserveIds) throws DataAccessException, HibernateException { // Container für die Objekte final List<Object> all = new ArrayList<Object>(); final XStream stream = initXStream(session, true); final XStream defaultXStream = initXStream(session, false); session.flush(); // Alles laden List<?> list = session.createQuery("select o from java.lang.Object o").setReadOnly(true).list(); list = (List<?>) CollectionUtils.select(list, PredicateUtils.uniquePredicate()); final int size = list.size(); log.info("Writing " + size + " objects"); for (final Iterator<?> it = list.iterator(); it.hasNext(); ) { final Object obj = it.next(); if (log.isDebugEnabled()) { log.debug("loaded object " + obj); } if ((obj instanceof HistoryEntry || obj instanceof PropertyDelta) && includeHistory == false) { continue; } Hibernate.initialize(obj); final Class<?> targetClass = HibernateProxyHelper.getClassWithoutInitializingProxy(obj); final ClassMetadata classMetadata = session.getSessionFactory().getClassMetadata(targetClass); if (classMetadata == null) { log.fatal("Can't init " + obj + " of type " + targetClass); continue; } // initalisierung des Objekts... defaultXStream.marshal(obj, new CompactWriter(new NullWriter())); if (preserveIds == false) { // Nun kann die ID gelöscht werden classMetadata.setIdentifier(obj, null, EntityMode.POJO); } if (log.isDebugEnabled()) { log.debug("loading evicted object " + obj); } if (this.ignoreFromTopLevelListing.contains(targetClass) == false) { all.add(obj); } } // und schreiben try { writer.write("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"); } catch (final IOException ex) { // ignore, will fail on stream.marshal() } log.info("Wrote " + all.size() + " objects"); final MarshallingStrategy marshallingStrategy = new ProxyIdRefMarshallingStrategy(); stream.setMarshallingStrategy(marshallingStrategy); stream.marshal(all, new PrettyPrintWriter(writer)); }
/** Performs tasks to resolve the lazy instantiation. */ private synchronized void init() { if (!initialized) { // Mimic the behavior of XStream's JVM class String vendor = System.getProperty("java.vm.vendor"); float version = 1.3f; try { version = Float.parseFloat(System.getProperty("java.version").substring(0, 3)); } catch (NumberFormatException nfe) { // Keep the default } Class unsafe = null; try { unsafe = Class.forName("sun.misc.Unsafe", false, getClass().getClassLoader()); } catch (ClassNotFoundException cnfe) { // Keep the default } ReflectionProvider reflectionProvider = null; if ((vendor.contains("Sun") || vendor.contains("Oracle") || vendor.contains("Apple") || vendor.contains("Hewlett-Packard") || vendor.contains("IBM") || vendor.contains("Blackdown")) && version >= 1.4f && unsafe != null) { try { reflectionProvider = (ReflectionProvider) Class.forName( "com.thoughtworks.xstream.converters.reflection.Sun14ReflectionProvider", false, getClass().getClassLoader()) .newInstance(); } catch (InstantiationException ie) { reflectionProvider = new PureJavaReflectionProvider(); } catch (IllegalAccessException iae) { reflectionProvider = new PureJavaReflectionProvider(); } catch (ClassNotFoundException cnfe) { reflectionProvider = new PureJavaReflectionProvider(); } } else { reflectionProvider = new PureJavaReflectionProvider(); } HierarchicalStreamDriver driver = new DomDriver(); xs = new XStream(reflectionProvider, driver); xs.setMarshallingStrategy(new LockssReferenceByXPathMarshallingStrategy(lockssContext)); xs.registerConverter(new LockssDateConverter()); initialized = true; } }
/** @return */ private XStream initXStream(final Session session, final boolean nullifyPk) { final XStream xstream = new XStream() { @Override protected MapperWrapper wrapMapper(final MapperWrapper next) { return new HibernateMapper(new HibernateCollectionsMapper(next)); } }; // Converter für die Hibernate-Collections xstream.registerConverter(new HibernateCollectionConverter(xstream.getConverterLookup())); xstream.registerConverter( new HibernateProxyConverter( xstream.getMapper(), new PureJavaReflectionProvider(), xstream.getConverterLookup()), XStream.PRIORITY_VERY_HIGH); xstream.setMarshallingStrategy( new XStreamMarshallingStrategy(XStreamMarshallingStrategy.RELATIVE)); init(xstream); return xstream; }
@Test public void synchronizedCollectionText() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Map<String, String> map = Collections.synchronizedMap(new LinkedHashMap<String, String>()); map.put("hello", "world"); map.put("second", "value"); XStream xs = new XStream(); xs.setMarshallingStrategy( new MigratingMarshallingStrategy(new MigrationManager("com.t3.", true))); System.out.println(xs.toXML(map)); Map<String, String> map2 = (Map<String, String>) xs.fromXML(xs.toXML(map)); Assert.assertEquals(map, map2); Assert.assertEquals(map.getClass(), map2.getClass()); // make shure that is map is of the same type Field f = map.getClass().getDeclaredField("m"); f.setAccessible(true); Assert.assertEquals(f.get(map).getClass(), LinkedHashMap.class); Assert.assertEquals(f.get(map2).getClass(), LinkedHashMap.class); }
private Pair<String, Object> parseEntry(Node node) { NodeList nl = node.getChildNodes(); String name = null; Object value = null; for (int i = 0; i < nl.getLength(); i++) { Node ii = nl.item(i); ii = resolve(ii); System.out.println(" entry, name <" + ii.getNodeName() + ">"); if (ii.getNodeName().equals("field.core.dispatch.iVisualElement_-VisualElementProperty")) { NodeList childNodes = ii.getChildNodes(); for (int j = 0; j < childNodes.getLength(); j++) { Node cn = childNodes.item(j); cn = resolve(cn); System.out.println(" property <" + cn.getNodeName() + ">"); if (cn.getNodeName().equals("name")) { name = cn.getTextContent(); System.out.println(" name is <" + name + ">"); } } } else if (ii.getNodeName().equals("string")) { value = ii.getTextContent().trim(); } else if (ii.getNodeName().equals("float")) { value = Float.parseFloat(ii.getTextContent().trim()); } else if (ii.getNodeName().equals("double")) { value = Double.parseDouble(ii.getTextContent().trim()); } else { ; // System.out.println(" node is xml <" + loadProperties + ">"); if (loadProperties) { try { String xml = nodeToString(ii); if (xml.trim().length() == 0) continue; if (xml.contains("reference=")) continue; if (xml.contains("id=")) continue; ; // System.out.println(" xml is <" + xml + ">"); xml = "<object-stream>" + xml + "</object-stream>"; XStream stream = new XStream(new Sun14ReflectionProvider()); stream.registerConverter(new ChannelSerializer()); stream.registerConverter(new FloatBufferSerializer()); stream.registerConverter(new MarkerSerializer(stream.getClassMapper())); stream.setMarshallingStrategy(new ReferenceByIdMarshallingStrategy()); Object o = stream.createObjectInputStream(new StringReader(xml)).readObject(); value = o; ; // System.out.println(" -- loaded <" + value + ">"); } catch (Throwable t) { System.out.println( " trouble loading contents of <" + ii.getNodeName() + "> continuing on"); } } } } // System.out.println(" got <" + name + " = " + value + ">"); if (name == null) return null; if (value == null) return null; else return new Pair<String, Object>(name, value); }
/** * Configure the XStream instance with this marshaller's bean properties. * * @param xstream the {@code XStream} instance */ protected void configureXStream(XStream xstream) { if (this.converters != null) { for (int i = 0; i < this.converters.length; i++) { if (this.converters[i] instanceof Converter) { xstream.registerConverter((Converter) this.converters[i], i); } else if (this.converters[i] instanceof SingleValueConverter) { xstream.registerConverter((SingleValueConverter) this.converters[i], i); } else { throw new IllegalArgumentException( "Invalid ConverterMatcher [" + this.converters[i] + "]"); } } } if (this.marshallingStrategy != null) { xstream.setMarshallingStrategy(this.marshallingStrategy); } if (this.mode != null) { xstream.setMode(this.mode); } try { if (this.aliases != null) { Map<String, Class<?>> classMap = toClassMap(this.aliases); for (Map.Entry<String, Class<?>> entry : classMap.entrySet()) { xstream.alias(entry.getKey(), entry.getValue()); } } if (this.aliasesByType != null) { Map<String, Class<?>> classMap = toClassMap(this.aliasesByType); for (Map.Entry<String, Class<?>> entry : classMap.entrySet()) { xstream.aliasType(entry.getKey(), entry.getValue()); } } if (this.fieldAliases != null) { for (Map.Entry<String, String> entry : this.fieldAliases.entrySet()) { String alias = entry.getValue(); String field = entry.getKey(); int idx = field.lastIndexOf('.'); if (idx != -1) { String className = field.substring(0, idx); Class<?> clazz = ClassUtils.forName(className, this.beanClassLoader); String fieldName = field.substring(idx + 1); xstream.aliasField(alias, clazz, fieldName); } else { throw new IllegalArgumentException("Field name [" + field + "] does not contain '.'"); } } } } catch (ClassNotFoundException ex) { throw new IllegalStateException("Failed to load specified alias class", ex); } if (this.useAttributeForTypes != null) { for (Class<?> type : this.useAttributeForTypes) { xstream.useAttributeFor(type); } } if (this.useAttributeFor != null) { for (Map.Entry<?, ?> entry : this.useAttributeFor.entrySet()) { if (entry.getKey() instanceof String) { if (entry.getValue() instanceof Class) { xstream.useAttributeFor((String) entry.getKey(), (Class<?>) entry.getValue()); } else { throw new IllegalArgumentException( "'useAttributesFor' takes Map<String, Class> when using a map key of type String"); } } else if (entry.getKey() instanceof Class) { Class<?> key = (Class<?>) entry.getKey(); if (entry.getValue() instanceof String) { xstream.useAttributeFor(key, (String) entry.getValue()); } else if (entry.getValue() instanceof List) { @SuppressWarnings("unchecked") List<Object> listValue = (List<Object>) entry.getValue(); for (Object element : listValue) { if (element instanceof String) { xstream.useAttributeFor(key, (String) element); } } } else { throw new IllegalArgumentException( "'useAttributesFor' property takes either Map<Class, String> " + "or Map<Class, List<String>> when using a map key of type Class"); } } else { throw new IllegalArgumentException( "'useAttributesFor' property takes either a map key of type String or Class"); } } } if (this.implicitCollections != null) { for (Map.Entry<Class<?>, String> entry : this.implicitCollections.entrySet()) { String[] collectionFields = StringUtils.commaDelimitedListToStringArray(entry.getValue()); for (String collectionField : collectionFields) { xstream.addImplicitCollection(entry.getKey(), collectionField); } } } if (this.omittedFields != null) { for (Map.Entry<Class<?>, String> entry : this.omittedFields.entrySet()) { String[] fields = StringUtils.commaDelimitedListToStringArray(entry.getValue()); for (String field : fields) { xstream.omitField(entry.getKey(), field); } } } if (this.annotatedClasses != null) { xstream.processAnnotations(this.annotatedClasses); } if (this.autodetectAnnotations) { xstream.autodetectAnnotations(true); } }