Currently evaluating InfluxDB and want to find out if serialized objects (e.g. using Java) can be stored / retrieved from InfluxDB and what is the process for it?
According to wikipedia, this database supports the following types of values:
Values can be 64-bit integers, 64-bit floating points, strings, and booleans.
You can serialize Java objects into byte streams; and byte streams can be represented as hex strings.
So, theoretically the answer is yes - it should be possible to store serialized Java objects in this database. To read back, you just reverse that process.
If that is a good idea is a completely different question. It sounds rather inefficient; and storing serialized objects is by itself not a great idea. First of all, it is a big detour - turn an object into a byte stream into a hex string (and reverse that). Then: java object serialization has is a beast of its own - you have to be carefully for example to not introduce version incompatibilities. It is really annoying when you release a new version of your Java code and that code throws an exception when you try to deserialize previously stored objects.
Therefore more modern approaches prefer to serialize into different formats (JSON for example), or use tools to translate fields directly to different table columns.
Related
This question already has answers here:
How to send a Java Object in binary format and receive in C server?
(3 answers)
Closed 6 years ago.
I have a java object which I want to send from Java Client(written in Java) using serialization or any other techniques and want to deserialize the same object in Server (written in C) ?
I tried to read the message received in C, but it is some hexadecimal values.
How can I print the same object parameters value in my server written in C.
Thanks in Advance
I would probably serialise the object to JSON; this has the advantage that the serialised object is human-readable. See this answer for a guide on how to serialise to JSON, and this for help on deserialising the result in C.
It depends how are you serialize your java objects. If you're using standard Java serialization mechanism this is could be painful to deserialize it into same object in C. At least you will have two parallel hierarchy of objects in C and Java to support.
I would recommend to take a look into external serialization libraries with code generation which supports both languages, C and Java:
For example:
Apache Thrift
ProtoBuf
I have a java object which I want to send from Java Client(written in Java) using serialization or any other techniques and want to deserialize the same object in Server (written in C) ?
You can't.
C does not even know about objects and when thinking of C++ as another OO language: this has a completly different concept of objects.
So you cant "recreate" a Java object outside a JVM.
But what you most likely want is to tranfer the data your Java object holds to the C-program.
In order to do this you have to specify a protocoll that both, the Java program and the C-program understand. One possibility has been proposed by #Halmackenreuter. Others are XML or CSV. The consensus of all three is: whe convert the data into a plain text file and transfer this to the other end who knows how to read (parse) it. This process is called marshalling/unmarshalling.
there is requirement in which I don't have to use Json. And looking for some binary representation of data. The object needs to be converted into binary format and then have to send across the network and retrieve the same in Server (written in c – Ajay Yadav
Then you have to specify (or know) this binary format and create the stream of bytes to sent over the network.
somebody suggested to use ByteBuffer it to the same. But still struggling on how to use the same. – Ajay Yadav
This still means you cannot send "the java object". You have to put the objects data into the ByteBuffer in the order the protocoll expects them to be.
I need to parse untrusted Java serialized objects. The data is given to me as a byte array (written at some point by ObjectOutputStream).
I do not want to simply call ObjectInputStream.readObject() and/or load the actual object. I am looking for a way to safely parse the bytes and grab field names & values.
--
Here's a little summary of my attempt so far, after taking a look at the ObjectInputStream procedure for deserializing objects.
I have tried to extract field types/names (as unicode strings) recursively based on expected stream constants. I end up with a list of field names whose values should appear in the byte array in order. I am uneasy about this approach because it is probably buggy. Especially accommodating for what seems to be individual serialization protocols followed by HashMap, ArrayList, etc. But it might work, if I can figure out a way to read the bytes that represent field values:
I can try to read and store primitives based on size/offset, but when I encounter my first object, it gets a bit more complicated -- there is no clear way to distinguish between which bytes are associated with which values anymore (without actually loading the object in the way that ObjectInputStream probably does?).
--
Can anyone suggest either a potential solution that I'm obviously looking past, or a trusted library that can help parse the serialized data without loading objects?
Thank you for reading, and for all comments/suggestions!!! I apologize if something is unclear and I would be happy to clarify if you bear with me.
You can't do this in principle. Any Java class can take over its own Serialization and write arbitrary data to the stream that only it knows how to parse and reconstruct, via code that is only invoked during deserialization.
What are methods to convert data (ints, strings) to bytes in Java? I am looking for methods other than using the Serializable class. I researched and found things like ByteOutputStream.
Can I just parse strings and ints to a byte data type?
Any suggestions?
Have a look at DataInputStream and DataOutputStream, they convert all Java data types to bytes and read/write to an underlying Input/OutputStream.
If you need to read or write ints, longs etc.. to a file, then these are the classes for you.
If instead you are just interested in how to convert then to bytes for other purposes, have a look at the source code of those classes, they convert to big-endian.
Classes supporting the DataOutput interface will do what you want. Use DataInput to read the stream back to data.
The standard encoding method used by Java when serializing is, just as your own thoughts, a simple translation of the fields into a byte stream.
Primitives as well as non-transient, non-static referenced objects are encoded into the stream. Each object that is referenced by the serialized object and must also be serialized.
Other languages, such as PHP for example, serializes to a pretty much human readable format and some implementations serialize to JSON or XML.
In my own mind though, true serialization should be binary byte-per-byte representation of the data. That way it's possible to quickly read all the data up into memory again and it can be executed as is.
In different languages I need to provide users with a stream of JSON objects with an interface similar to the following:
JSONObject json = stream.nextJSON();
Since it is a stream, each call will block until a full object has been retrieved. This means it makes no sense to try and encapsulate each JSON object inside a big array. An extra layer of structure and processing has to be added to the stream.
I have thought of two options:
Segmenting the stream with the null-termination character.
Writing a primitive parser that understand JSON scope so can detect the end of an object.
Each of the above have a number of potential issues to discuss: How will null-termination interact with the file system, socket or underlying streams in C++, Java and other languages? What edge cases would we need to take in to account when parsing? (different types of quote symbol might confuse a parser, for example). Furthermore, there might be alternatives to the two above.
So the question is: What is the best way to provide a JSON InputStream?
Well Google already thought about it apparently:
http://sites.google.com/site/gson/streaming
Yes, I know it's bad practice and I should instead normalize my tables. That put aside, is it possible to serialize a String [] array and store it in the database?
I am from the lenient and forgiving world of PHP, where invoking the serialize() function and would convert the array into a string.
Is there an equivalent of doing such heresy in Java?
Apart from normalization, are there more elegant ways of storing String Arrays in the database?
In case it's applicable, I am using the jdbc driver for my MySQL connections.
Yes. You can serialize any Java objects and store the serialized data into MySQL.
If you use the regular serialization (ObjectOutputStream), the output is always binary. Even String is serialized into binary data. So you have to Base64 encode the stream or use a binary column like BLOB.
This is different from PHP, whose serialize() converts everything into text.
You can also use the XML serialization in Java (XMLEncoder) but it's very verbose.
If you're thinking in terms of raw arrays, you're still writing PHP in Java.
Java's an object-oriented language. An array of Strings really isn't much of an abstraction.
You'll get perfectly good advice here telling you that it's possible to serialize that array of Strings into a BLOB that you can readily store in MySQL, and you can tell yourself that leniency is a virtue.
But I'll going to remind you that you're losing something by not thinking in terms of objects. They're really about abstraction and encapsulation and dealing with things at a higher level than bare metal ints, Strings, and arrays.
It'd be a good exercise to try and design an object that might encapsulate an array or another more sophisticated data structure of child objects that were more than Strings. There'd be a 1:m relationship between parent and child that would better reflect the problem you were really trying to solve. That would be a far more object-oriented design than the one you're proposing here.
There are various good serialization/deserialization libraries that automatically convert JavaBean objects to/from XML and JSON strings. One I've had good experience with is XStream.
Java's built-in support for serialization can do the same thing, and you can write custom serialization/deserialization methods for Java to call.
You can roll your own serialization methods too, eg converting to and from a comma-separated value (CSV) format.
I'd opt for a library like XStream first, assuming there's a very compelling reason not to normalize the data.
You don't want to serialize the array. I'm not sure why you'd serialize it in PHP either, because implode() and explode() would be more appropriate. You really should normalize your data, but aside from that, you could very easily Google a solution for converting an array to a string.
But surely the more logical thing to do would be to save each string as its own record with a suitable identifier. That would probably be less coding than serializing -- a simple loop through the elements of the array -- and would result in a clean database design, rather than some gooey mess.
If you really don't want to normalize this values into a separate table where each string would be in its own row, then just convert your array to a list of comma separated values (possibly escaping commas somehow). Maybe quoting each string so that "str1","str2".
Google for CSV RFC for spec on how this should be properly escaped.