1. json-smart
    • If you want to keep JSON, look for other frameworks like "json-smart": URL_http://code.google.com/p/json-smart/ [ URL_http://code.google.com/p/json - smart/] They claim to be 2-3 times faster than Jackson.
    • Explore all reviews
  2. org.hibernate
    • it is more efficient from a bandwidth perspective to exlucde certain large data properties.
    • Explore all reviews
  3. org.neo4j
    • Check out URL_http://neo4j.org/ [neo4J] The internal representation of the graph would be then delegated to the database and people have been working on this for years, so I would expect the representation to be efficient and performant.
    • Explore all reviews
  4. jbutterfly
    • Replace the raw sockets with, at least, [ZeroMQ]( URL_http://www.zeromq.org /) if nothing more robust.
    • Explore all reviews
  5. org.msgpack
    • You should consider using MessagePack as it is full compatible with Redis and Lua, it is a great compression on JSON: URL_http://msgpack.org/ [ URL_http://msgpack.org/ ] It implies some Lua code to compress and uncompress, but the cost should be small.
    • Explore all reviews
  6. thrift-protobuf-compare
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • One thing that might be interesting wrt Jackson is the performance aspect (Jackson is specifically designed as a very high performance JSON package), see [ URL_http://code.google.com/p/thrift-protobuf-compare/wiki/Benchmarking ] and [ URL_http://www.cowtowncoder.com/blog/archives/2009/09/entry_326.html ].
    • Explore all reviews
  7. jetty
    • Infact jetty or netty can support higher load, high number of connections etc.
    • Any performance tip or special configuration for Jetty?
    • It would be important if the processing of the messages (parsing and creating) would be easy and fast on both server and client side since the application should feature real time speed.
    • Explore all reviews
  8. aalto-xml
    • ); but for async nothing yet that I am aware of.The lib you refer to seems badly named; it does not seem to do real asynchronous processing, but merely allow one to parse sequence of JSON documents (which multiple other libs allow doing as well) If there were people who really wanted this, writing one is not impossible -- for XML there is URL_http://wiki.fasterxml.com/AaltoHome [Aalto] , and handling JSON is quite a bit simpler than XML.For what it is worth, there is actually URL_http://jira.codehaus.org/browse/JACKSON-39 [this-feature-request] to add non-blocking parsing mode for URL_http://jackson.codehaus.org [Jackson] ; but very few users have expressed interest in getting that done (via voting for the feature request).
    • Explore all reviews
  9. io.netty
    • Infact jetty or netty can support higher load, high number of connections etc.
    • Explore all reviews
  10. org.mvel
    • By 'easily', I mean high level configuration API that would faster for me to use than to write my own expression evaluator.
    • Explore all reviews
  11. piccolo
  12. org.glassfish.jersey
    • GSON is indeed a very popular library, but for example, Jackson has a large installed base due to its inclusion as default JSON library in both RESTEasy and Jersey.
    • And voil!
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Explore all reviews
  13. cassandra
    • In Cassandra, writes are much more efficient than reads so it is beneficial to avoid reads before writes if possible.
    • Explore all reviews
  14. jdbchelper
  15. restlet
  16. org.zeromq
    • Replace the raw sockets with, at least, [ZeroMQ]( URL_http://www.zeromq.org /) if nothing more robust.
    • Explore all reviews
  17. javax.jms
  18. json-p
    • If so can get a 200 but if not CORS enabled or setup for jsonp will not trigger success.
    • Explore all reviews
  19. kryo
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • Explore all reviews
  20. simple-http
    • In short, my purpose is to serve web services using JSON and HTTP Get/Post in a maximum possible lightweight solution.
    • Explore all reviews
  21. org.jboss
    • i would like to using only JAXB(native for JBOSS AS 7) for best performance, avoiding others "jar".
    • i would like to using only JAXB(native for JBOSS AS 7) for best performance, avoiding others "jar".
    • Explore all reviews
  22. java.io
    • Obviously it depends on the average line size of the output, but that could very well be fewer batches than one per line.
    • Explore all reviews
  23. neo4j-graphdb
    • Check out URL_http://neo4j.org/ [neo4J] The internal representation of the graph would be then delegated to the database and people have been working on this for years, so I would expect the representation to be efficient and performant.
    • Explore all reviews
  24. org.jboss.resteasy
    • GSON is indeed a very popular library, but for example, Jackson has a large installed base due to its inclusion as default JSON library in both RESTEasy and Jersey.
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Explore all reviews
  25. apache-io
    • I was just hoping for some other solution as doing something like this kinda defeats the performance benefits of using the streaming parser.
    • Explore all reviews
  26. boon
    • Give boon a try: URL_https://github.com/RichardHightower/boon [ URL_https://github.com/RichardHightower/boon ] It is wicked fast: URL_https://github.com/RichardHightower/json-parsers-benchmark [ URL_https://github.com/RichardHightower/json-parsers-benchmark ] Don't take my word for it... check out the gatling benchmark.
    • It also has a index overlay mode that is even faster.
    • With Boon Index Overlay mode, it is even faster.
    • :) (and has a super low memory, direct from bytes mode with UTF-8 encoding on the fly).
    • It also has the fastest JSON to JavaBean mode too.
    • It is new, but if speed and simple API is what you are looking for, I don't think there is a faster or more minimalist API.
    • Explore all reviews
  27. resteasy
    • I have used both Jackson and Gson for the JSON support with RESTEasy and it is quite simple.
    • Explore all reviews
  28. stax
    • It gives you the ease of XPath with the performance of STAX parsing; honestly (I am being unbiased, seriously) -- it is awesome.
    • It's URL_http://www.thebuzzmedia.com/software/simple-java-xml-parser- sjxp/#performance [really-fast] and it works on Android.
    • Explore all reviews
  29. org.boon
    • It compares Boon, Jackson, Smart JSON and GSON.
    • At times Boon is 4x faster.
    • :)GSON is better than most at I/O, but Boon does best all around (and best at I/O), and it has an index overlay mode that is even faster (look at the second set.. the index overlay puts Boon way over the top).
    • Boon is wicked fast.
    • Explore all reviews
  30. genson
    • However main advantages of Genson are : faster then Gson, more usefull features and is more flexible (you can add yourself new features in a more easy way).
    • Compared to Jackson it is more a matter of vision, jackson tries to handle a lot of cases but by making extension really hard, Genson takes another approach
    • provide nice features but stay open to extension.
    • This will work on Jackson as well as many other Java JSON libs (Gson, Genson at least), and will also be faster method to use.
    • Its performances were not good (especially compared to Jackson or Genson).With the latest versions it has improved as they also provide a streaming api, but its still not fast enough.
    • Actually Genson is faster and has more features than Gson and has performances close to jackson (but its a lot more lightweight) see URL_http://code.google.com/p/genson/wiki/Metrics [ URL_http://code.google.com/p/genson/wiki/Metrics ] .
    • Explore all reviews
  31. net.sf.spring-json
  32. commons-jexl
    • By 'easily', I mean high level configuration API that would faster for me to use than to write my own expression evaluator.
    • Explore all reviews
  33. org.glassfish.main.core
  34. org.apache.cxf
    • JAX-RS is a java standard, Jackson library is fast and handles circular references and Apache CXF needs only a couple of lines of configuration to setup and start running.
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Explore all reviews
  35. io.gatling
    • Give boon a try: URL_https://github.com/RichardHightower/boon [ URL_https://github.com/RichardHightower/boon ] It is wicked fast: URL_https://github.com/RichardHightower/json-parsers-benchmark [ URL_https://github.com/RichardHightower/json-parsers-benchmark ] Don't take my word for it... check out the gatling benchmark.
    • It also has a index overlay mode that is even faster.
    • It can parse JSON to Maps and Lists faster than any other lib can parse to a JSON DOM and that is without Index Overlay mode.
    • It also has a very fast JSON lax mode and a PLIST parser mode.
    • Explore all reviews
  36. quick-json
    • You can prefer quick-json parser to meet your requirement... quick-json parser is very straight forward, flexible, very fast and customizable.
    • URL_https://code.google.com/p/quick-json/ [quick-json-parser] is very straight forward, flexible, very fast and customizable.
    • Explore all reviews
  37. org.springframework
    • I like to know which of these are best and more efficient in performance perspective and security.
    • The huge response object sits in memory and can't be GC'd until the last item has been handled.
    • I don't know enough about Spring to know about ModelAndView part, but I know enough about Jackson to say that the performance is unlikely to be problematic for Jackson filtering.One reason why filtering approaches are not trivially simple is because they try to balance usability with performance -- and as such, both JSON Views and Filters have very low overhead.
    • It's reasonably fast, and has good documentation.
    • JSON seem to be a lightweight and effective message container for us.
    • Explore all reviews
  38. com.google.protobuf
    • One last note : The object mapper is thread safe and having one static instance like in the example I just submitted will prevent you from having the slight instantiation overhead.
    • Actually, I disagree on your "scalability" and "maintenace" / "change" points re protobuf: protobuf is specifically designed for scalability, with dense output (smaller than json etc), and cheap processing (especially compared to text protocols).
    • Protobuf is very handy, and is designed to be highly performant (cheaper to process, smaller output) and very version tolerant but browsers are better at processing JSON.
    • performant and efficient data transfer.
    • The advantage of CODETERM5 is, that is fairly efficient compared to CODETERM6 and well accepted.
    • Explore all reviews
  39. org.codehaus.jettison
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • Two important notes: 1) This code is provided as-is; specifically I have not thoroughly tested it beyond my own limited use, and 2) The fact that this problem is virtually non-existent elsewhere on the internet, as well as the fact that this seems to be a relatively basic operation that Jettison should perform, strongly suggests to me that we're doing something fundamentally wrong and that this solution shouldn't be necessary.
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Note however that XStream really is an XML-based object serializer; so while it does have JSON compatibility support, it goes through JSON->XML converter (Jettison) so any size or performance benefits JSON may have are lost.
    • Explore all reviews
  40. com.fasterxml.jackson
    • And with Jackson don't help me when I need to parse large files, so for my app GSON was the best, even more slow, can read large files.
    • Solve the out of memory problem.
    • I've seen some performance metrics on GSON - FlexJSON and Jackson Mapper are also easy to use APIs for converting POJO into JSON, and have better overall speed/performance than GSON.
    • The root cause it that your data is too large to be held in memory.
    • seems like jackson need them and gson doesn't right, this is a difference in performance.
    • I dont't know about performance compared to Jackson, but it's hard to be simpler than this... Gson is a stable and widely used library.
    • Explore all reviews
  41. org.json
    • For my taste it is a bit less elegant than having a specific JsonException but if is not possible otherwise that is still good.
    • And answer is somewhat bogus too :).Json.org's lib is not efficient in any way (and light-weight only if you count size of code itself).
    • GSON is a very powerful library for convert JSON-Java Object and viceversa..
    • I'm reading the file into memory and parsing it using: CODESNIPPET_JAVA1 .
    • Too fast :( raaa.
    • 2 Extracted _invalid_ JSON string literal: "Apple Inc. (NASDAQ:AAPL) shares continued to lead large cap tech stocks in top performance this year.
    • Explore all reviews
  42. com.google.code.gson
    • The power of GSON is not how fast it parses, but how fast it is to write and maintain the code required for a large number of production cases.
    • I believe this captures the spirit of JSON much better than a "manual parser" approach.
    • (addition to above: official numbers were included -- streaming Gson is faster than databinding, but not up to Jackson performance level).
    • My problem is more, if there is a structure issue somewhere in the json is there a way to "skip and continue" in GSON ?
    • I mean i have to create 10,000 java objects for 1000 json results.I am looking for super fast and memory efficient way to do it as json i get is very huge.
    • ^this, but would this method be faster/less costly?
    • Explore all reviews
  43. com.google.gwt
    • Finally you can use CODETERM6 as well, but it can have some performance issues.
    • Slow iteration through a JSONArray in GWT.
    • (because it will not need any conversion for sending to server) And if i am using Json it will give good performance like java?
    • In GWT 2.1, CODETERM10 became deprecated and two more methods were introduced - CODETERM11 (uses CODETERM12 internally) and CODETERM13 (the safe approach).
    • I'm using GWT to build an application, and I'm facing serious speed issues with something that I thought would be pretty fast.
    • The minute is in development mode, but I don't know if it would be any faster when I compile it.
    • Explore all reviews
  44. net.sf.json-lib
    • Usually libraries like GSON or Jackson (mentioned above) offer some validations in this aspect avoiding mal-formed json input, and usually (I have worked with both) they do quite well on performance; also using a json lib would provide you with other functionality to extend in the future if you need.
    • Yeah, it is sometimes a pity when devs are too reluctant -- org.json package specifically is so primitive that using a proper JSON library (Gson, Jackson, json-lib) would simplify life a lot for most cases.
    • CODETERM3 provides a lot of performance benefits compared to the ordered alternatives, and hence is used more often in cases where ordering does not matter.
    • It comes down to the degree of flexibility you want, the performance you need, and whether you want a simple API or if you don't mind a more complex one.
    • Json-lib is sometimes easier to get to grasp with for smaller tasks that do not require top-speed, but with still completely acceptable results.Gson as also a good reputation and is very flexible, however the previous benchmarks I came across seemed to indicate that it did not perform as well as Jackson.
    • I've used URL_http://json-lib.sourceforge.net/ [JSONLib] , URL_http://flexjson.sourceforge.net/ [FlexJSON] and URL_http://code.google.com/p/google-gson/ [Gson] all with great success.
    • Explore all reviews
  45. net.sf.flexjson
    • I've seen some performance metrics on GSON - FlexJSON and Jackson Mapper are also easy to use APIs for converting POJO into JSON, and have better overall speed/performance than GSON.
    • By default it uses double if its a decimal and long if its an integer.
    • I want to go with Jackson because it is much faster than the alternatives, but I like FlexJSON the most.
    • Other than performance, there's URL_http://www.cowtowncoder.com/blog/archives/2010/11/entry_434.html [this- blog-post] ("7 Jackson killer features") that outlines what Jackson has to offer on its own (not considering integration with frameworks) -- other libraries have their own strengths, and for URL_http://flexjson.sourceforge.net/ [flex-json] I understand its output side (writing JSON) is quite flexible and powerful.
    • Try the URL_http://code.google.com/p/google-gson/ [GSon] from google and and URL_http://flexjson.sourceforge.net/ [FlexJson] Both are recommended .
    • Other than performance, there's URL_http://www.cowtowncoder.com/blog/archives/2010/11/entry_434.html [this- blog-post] ("7 Jackson killer features") that outlines what Jackson has to offer on its own (not considering integration with frameworks) -- other libraries have their own strengths, and for URL_http://flexjson.sourceforge.net/ [flex-json] I understand its output side (writing JSON) is quite flexible and powerful.
    • Explore all reviews
  46. javax.xml
    • The collect of phone numbers is of size 1 and is correctly bound by square brackets.
    • Since I am more familiar with Jackson, here are some aspects where I think Jackson has more complete support than Gson (apologies if I miss a Gson feature): Extensive annotation support; including full inheritance, and advanced "mix-in" annotations (associate annotations with a class for cases where you can not directly add them) Streaming (incremental) reading, writing, for ultra-high performance (or memory-limited) use cases; can mix with data binding (bind sub-trees) -- EDIT latest versions of Gson also include streaming reader Tree model (DOM-like access); can convert between various models (tree <-> java object <-> stream) Can use any constructors (or static factory methods), not just default constructor Field and getter/setter access (earlier gson versions only used fields, this may have changed) Out-of-box JAX-RS support Interoperability: can also use JAXB annotations, has support/work-arounds for common packages (joda, ibatis, cglib), JVM languages (groovy, clojure, scala) Ability to force static (declared) type handling for output Support for deserializing polymorphic types (Jackson 1.5) -- can serialize AND deserialize things like List correctly (with additional type information) Integrated support for binary content (base64 to/from JSON Strings) .
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • Explore all reviews
  47. com.googlecode.json-simple
    • You can use URL_https://code.google.com/p/json-simple/ [json-simple] its a high performance library and its very easy to use : CODESNIPPET_JAVA1 .
    • Which is annoying, because it means people then deviate from the standard without a problem, and wonder why they run into problems later when they use a stricter implementation.
    • You can use URL_https://code.google.com/p/json-simple/ [json-simple] its a high performance library and its very easy to use : CODESNIPPET_JAVA1 .
    • Which is annoying, because it means people then deviate from the standard without a problem, and wonder why they run into problems later when they use a stricter implementation.
    • A fast, simple, lightweight parser that I like is json-simple.
    • Explore all reviews
  48. spring
    • Run it on Jetty...it will be light-weight!.
    • Hmm, I'm not sure, it looks like it expects to be deployed in a war file, and I would rather avoid a heavyweight servlet container and all of that infrastructure, the API is just a small part of my project, I don't want to stuff the entire thing in a war just so I can support the API :-/.
    • Explore all reviews
  49. org.mongodb
    • If keys are numbers and values are numbers then it can be very compact in binary.
    • They are slow.
    • Explore all reviews
  50. com.google.appengine
    • My primary concern is having it be efficient, and after that, simple and elegant code.
    • It is stable and still actively developed, with version 2 has just been released couple of weeks ago.
    • Explore all reviews
  51. com.extjs
    • I like to know which of these are best and more efficient in performance perspective and security.
    • As far as ExtJS being heavy, I think it's worth its weight in (...wait for it) time saved developing.
    • Explore all reviews
  52. javax.xml.parsers
    • Almost the fastest.
    • 2nd slowest and fairly memory-intense, but necessary if you want/need the XML DOM to stick around in memory so you can operate on it.
    • Explore all reviews
  53. commons-httpclient
    • The main idea on what I suggested is that you completely off-load the UI, so even if it takes the same time, this time will be taken on a background thread and your UI will keep running fast and smooth.
    • If this line of code has only caused the problem once or twice it may be time to look for a general memory usage problem.
    • Try to determine how close to the memory limit the application is.
    • Explore all reviews
  54. xstream
    • Note however that XStream really is an XML-based object serializer; so while it does have JSON compatibility support, it goes through JSON->XML converter (Jettison) so any size or performance benefits JSON may have are lost.
    • XStream seems somewhat less flexible, and it's fairly slow.
    • parsing xml is more expensive than JSON in this case.
    • Explore all reviews
  55. org.yaml
    • You could also consider URL_http://www.yaml.org/ [YAML] which seems less used, but is more "powerful".
    • SQLite implements a very robust data storage engine that is extremely difficult to corrupt when you have power outages or programs that are hung in an inconsistent state due to errors.
    • This still says it all for me about XML and why it's still a valid choice for config files (from URL_http://www.tbray.org/ongoing/When/200x/2006/12/21/JSON [Tim-Bray] ): _"If you want to provide general-purpose data that the receiver might want to do unforeseen weird and crazy things with, or if you want to be really paranoid and picky about i18n, or if what youre sending is more like a document than a struct, or if the order of the data matters, or if the data is potentially long-lived (as in, more than seconds) XML is the way to go.
    • Explore all reviews
  56. sax
    • As it is designed for micro edition, it is really light-weight (small footprint) and IMHO really easy to use (much more easier than SAX/DOM etc.
    • Yes, JSON does have a toXML and you can make JSON.XMLtoJSON, but i need to add extra bits, and change a few bits around to satisfy the dojo requirements.As the quick bursts will be very strict in format, and typically be 3/4 lines line (50 at the most a (a recurring set of 3/4 line elements) holding in memory will not be too much of an issue..Thanks again for the comments so far..
    • SAX itself is very lightweight and fast, so I'm not sure why think it's too much.
    • Although JSON does seem less verbose (no closing tags for example), and is also provides a very easy means to pass data to Javascript, which is all the rage these days and hence probably one of the reasons for the big rise of JSON.
    • Also using a string buffer would actually be much less scalable** then using SAX because SAX doesn't require you to load the whole XML file into memory to use it.
    • If you have small files and you don't need to worry about performance, look into using the DOM.
    • Explore all reviews
  57. com.google.caliper
    • The reason is that I'm currently using URL_https://code.google.com/p/caliper/ [caliper] for some (micro-) benchmarks, and while the benchmark is _still running_ (or if I canceled it prematurely), the output file will not be a complete JSON document.
    • Explore all reviews
  58. junit
    • It takes time because it depends upon network accessibility, processor speed, memory capability etc.
    • Explore all reviews
  59. org.antlr
  60. org.apache.camel
    • My problem is that our old serialization was done manually and used Pascal casing instead of Camel casing ("MyVariable" instead of "myVariable"), and Jackson does Camel casing by default.
    • Explore all reviews
  61. org.joda
    • Since I am more familiar with Jackson, here are some aspects where I think Jackson has more complete support than Gson (apologies if I miss a Gson feature): Extensive annotation support; including full inheritance, and advanced "mix-in" annotations (associate annotations with a class for cases where you can not directly add them) Streaming (incremental) reading, writing, for ultra-high performance (or memory-limited) use cases; can mix with data binding (bind sub-trees) -- EDIT latest versions of Gson also include streaming reader Tree model (DOM-like access); can convert between various models (tree <-> java object <-> stream) Can use any constructors (or static factory methods), not just default constructor Field and getter/setter access (earlier gson versions only used fields, this may have changed) Out-of-box JAX-RS support Interoperability: can also use JAXB annotations, has support/work-arounds for common packages (joda, ibatis, cglib), JVM languages (groovy, clojure, scala) Ability to force static (declared) type handling for output Support for deserializing polymorphic types (Jackson 1.5) -- can serialize AND deserialize things like List correctly (with additional type information) Integrated support for binary content (base64 to/from JSON Strings) .
    • Explore all reviews
  62. kxml
    • Yes, JSON does have a toXML and you can make JSON.XMLtoJSON, but i need to add extra bits, and change a few bits around to satisfy the dojo requirements.As the quick bursts will be very strict in format, and typically be 3/4 lines line (50 at the most a (a recurring set of 3/4 line elements) holding in memory will not be too much of an issue..Thanks again for the comments so far..
    • From my own experience with kXML 2: I used it to parse XML files larger than 1 GB - Wikipedia dumps and I was very happy with performance / memory consumption etc.
    • Explore all reviews
  63. proguard
    • One thing to watch out for: After exporting my app and testing I ran into problems due to Proguard and GSON.
    • Explore all reviews
  64. org.apache.ibatis
    • Since I am more familiar with Jackson, here are some aspects where I think Jackson has more complete support than Gson (apologies if I miss a Gson feature): Extensive annotation support; including full inheritance, and advanced "mix-in" annotations (associate annotations with a class for cases where you can not directly add them) Streaming (incremental) reading, writing, for ultra-high performance (or memory-limited) use cases; can mix with data binding (bind sub-trees) -- EDIT latest versions of Gson also include streaming reader Tree model (DOM-like access); can convert between various models (tree <-> java object <-> stream) Can use any constructors (or static factory methods), not just default constructor Field and getter/setter access (earlier gson versions only used fields, this may have changed) Out-of-box JAX-RS support Interoperability: can also use JAXB annotations, has support/work-arounds for common packages (joda, ibatis, cglib), JVM languages (groovy, clojure, scala) Ability to force static (declared) type handling for output Support for deserializing polymorphic types (Jackson 1.5) -- can serialize AND deserialize things like List correctly (with additional type information) Integrated support for binary content (base64 to/from JSON Strings) .
    • Explore all reviews
  65. async-json-library
    • I have been working on this app for on and off for three months and have yet to see any memory issues at all.
    • Explore all reviews
  66. lucene
    • solved I used this PHP file to take care of everything, thanks for all the hints, they were very usufull, also I tried using lucene is faster especially for long n data bases, but unfortunately I cannot decide to move to a lucen DB CODESNIPPET_JAVA2 .
    • Explore all reviews
  67. eclipselink
    • Why is it using array indicators "[]", while bird, cat, and dog are not arrays?Second, is there a way to get rid of "bird", "cat", and "dog"?
    • Explore all reviews
  68. vanilla
    • vanilla JSON parser supplied with android can parse data, unfortunatelyit builds full JSON model in memory (like DOM parser for XML ) - this works fine forsmall data amounts, but is not practicable for slightly bigger data as it allocates and hogs a lot of memory.
    • Explore all reviews
  69. ognl
    • The json-path project I mentioned earlier uses too many regular expression which makes me a bit skeptical about its performance.
    • Explore all reviews
  70. caliper
    • The reason is that I'm currently using URL_https://code.google.com/p/caliper/ [caliper] for some (micro-) benchmarks, and while the benchmark is _still running_ (or if I canceled it prematurely), the output file will not be a complete JSON document.
    • (I don't like the Caliper web interface, because it is slow, does not scale to large experiment sets, and a lot of data fails to submit and is then missing from the run.)
    • But that is a nasty hack, and not robust towards future changes of caliper output.
    • Explore all reviews
  71. rhino
    • Important point here, 100GB won't fit into main memory, so I/O performance might be the bottleneck and should be optimized rather than the processing code.
    • Important point here, 100GB won't fit into main memory, so I/O performance might be the bottleneck and should be optimized rather than the processing code.
    • Explore all reviews
  72. javax.xml.xpath
    • This is probably the slowest and most memory intensive, BUT, one of the most convenient ways to query your data.
    • Explore all reviews
  1. javax.xml.xpath
    • This is probably the slowest and most memory intensive, BUT, one of the most convenient ways to query your data.
    • Explore all reviews
  2. junit
    • It takes time because it depends upon network accessibility, processor speed, memory capability etc.
    • Explore all reviews
  3. org.antlr
  4. org.apache.camel
    • My problem is that our old serialization was done manually and used Pascal casing instead of Camel casing ("MyVariable" instead of "myVariable"), and Jackson does Camel casing by default.
    • Explore all reviews
  5. org.joda
    • Since I am more familiar with Jackson, here are some aspects where I think Jackson has more complete support than Gson (apologies if I miss a Gson feature): Extensive annotation support; including full inheritance, and advanced "mix-in" annotations (associate annotations with a class for cases where you can not directly add them) Streaming (incremental) reading, writing, for ultra-high performance (or memory-limited) use cases; can mix with data binding (bind sub-trees) -- EDIT latest versions of Gson also include streaming reader Tree model (DOM-like access); can convert between various models (tree <-> java object <-> stream) Can use any constructors (or static factory methods), not just default constructor Field and getter/setter access (earlier gson versions only used fields, this may have changed) Out-of-box JAX-RS support Interoperability: can also use JAXB annotations, has support/work-arounds for common packages (joda, ibatis, cglib), JVM languages (groovy, clojure, scala) Ability to force static (declared) type handling for output Support for deserializing polymorphic types (Jackson 1.5) -- can serialize AND deserialize things like List correctly (with additional type information) Integrated support for binary content (base64 to/from JSON Strings) .
    • Explore all reviews
  6. kxml
    • Yes, JSON does have a toXML and you can make JSON.XMLtoJSON, but i need to add extra bits, and change a few bits around to satisfy the dojo requirements.As the quick bursts will be very strict in format, and typically be 3/4 lines line (50 at the most a (a recurring set of 3/4 line elements) holding in memory will not be too much of an issue..Thanks again for the comments so far..
    • From my own experience with kXML 2: I used it to parse XML files larger than 1 GB - Wikipedia dumps and I was very happy with performance / memory consumption etc.
    • Explore all reviews
  7. proguard
    • One thing to watch out for: After exporting my app and testing I ran into problems due to Proguard and GSON.
    • Explore all reviews
  8. org.apache.ibatis
    • Since I am more familiar with Jackson, here are some aspects where I think Jackson has more complete support than Gson (apologies if I miss a Gson feature): Extensive annotation support; including full inheritance, and advanced "mix-in" annotations (associate annotations with a class for cases where you can not directly add them) Streaming (incremental) reading, writing, for ultra-high performance (or memory-limited) use cases; can mix with data binding (bind sub-trees) -- EDIT latest versions of Gson also include streaming reader Tree model (DOM-like access); can convert between various models (tree <-> java object <-> stream) Can use any constructors (or static factory methods), not just default constructor Field and getter/setter access (earlier gson versions only used fields, this may have changed) Out-of-box JAX-RS support Interoperability: can also use JAXB annotations, has support/work-arounds for common packages (joda, ibatis, cglib), JVM languages (groovy, clojure, scala) Ability to force static (declared) type handling for output Support for deserializing polymorphic types (Jackson 1.5) -- can serialize AND deserialize things like List correctly (with additional type information) Integrated support for binary content (base64 to/from JSON Strings) .
    • Explore all reviews
  9. async-json-library
    • I have been working on this app for on and off for three months and have yet to see any memory issues at all.
    • Explore all reviews
  10. lucene
    • solved I used this PHP file to take care of everything, thanks for all the hints, they were very usufull, also I tried using lucene is faster especially for long n data bases, but unfortunately I cannot decide to move to a lucen DB CODESNIPPET_JAVA2 .
    • Explore all reviews
  11. eclipselink
    • Why is it using array indicators "[]", while bird, cat, and dog are not arrays?Second, is there a way to get rid of "bird", "cat", and "dog"?
    • Explore all reviews
  12. vanilla
    • vanilla JSON parser supplied with android can parse data, unfortunatelyit builds full JSON model in memory (like DOM parser for XML ) - this works fine forsmall data amounts, but is not practicable for slightly bigger data as it allocates and hogs a lot of memory.
    • Explore all reviews
  13. ognl
    • The json-path project I mentioned earlier uses too many regular expression which makes me a bit skeptical about its performance.
    • Explore all reviews
  14. caliper
    • The reason is that I'm currently using URL_https://code.google.com/p/caliper/ [caliper] for some (micro-) benchmarks, and while the benchmark is _still running_ (or if I canceled it prematurely), the output file will not be a complete JSON document.
    • (I don't like the Caliper web interface, because it is slow, does not scale to large experiment sets, and a lot of data fails to submit and is then missing from the run.)
    • But that is a nasty hack, and not robust towards future changes of caliper output.
    • Explore all reviews
  15. rhino
    • Important point here, 100GB won't fit into main memory, so I/O performance might be the bottleneck and should be optimized rather than the processing code.
    • Important point here, 100GB won't fit into main memory, so I/O performance might be the bottleneck and should be optimized rather than the processing code.
    • Explore all reviews
  16. com.google.caliper
    • The reason is that I'm currently using URL_https://code.google.com/p/caliper/ [caliper] for some (micro-) benchmarks, and while the benchmark is _still running_ (or if I canceled it prematurely), the output file will not be a complete JSON document.
    • Explore all reviews
  17. sax
    • As it is designed for micro edition, it is really light-weight (small footprint) and IMHO really easy to use (much more easier than SAX/DOM etc.
    • Yes, JSON does have a toXML and you can make JSON.XMLtoJSON, but i need to add extra bits, and change a few bits around to satisfy the dojo requirements.As the quick bursts will be very strict in format, and typically be 3/4 lines line (50 at the most a (a recurring set of 3/4 line elements) holding in memory will not be too much of an issue..Thanks again for the comments so far..
    • SAX itself is very lightweight and fast, so I'm not sure why think it's too much.
    • Although JSON does seem less verbose (no closing tags for example), and is also provides a very easy means to pass data to Javascript, which is all the rage these days and hence probably one of the reasons for the big rise of JSON.
    • Also using a string buffer would actually be much less scalable** then using SAX because SAX doesn't require you to load the whole XML file into memory to use it.
    • If you have small files and you don't need to worry about performance, look into using the DOM.
    • Explore all reviews
  18. xstream
    • Note however that XStream really is an XML-based object serializer; so while it does have JSON compatibility support, it goes through JSON->XML converter (Jettison) so any size or performance benefits JSON may have are lost.
    • XStream seems somewhat less flexible, and it's fairly slow.
    • parsing xml is more expensive than JSON in this case.
    • Explore all reviews
  19. org.yaml
    • You could also consider URL_http://www.yaml.org/ [YAML] which seems less used, but is more "powerful".
    • SQLite implements a very robust data storage engine that is extremely difficult to corrupt when you have power outages or programs that are hung in an inconsistent state due to errors.
    • This still says it all for me about XML and why it's still a valid choice for config files (from URL_http://www.tbray.org/ongoing/When/200x/2006/12/21/JSON [Tim-Bray] ): _"If you want to provide general-purpose data that the receiver might want to do unforeseen weird and crazy things with, or if you want to be really paranoid and picky about i18n, or if what youre sending is more like a document than a struct, or if the order of the data matters, or if the data is potentially long-lived (as in, more than seconds) XML is the way to go.
    • Explore all reviews
  20. commons-httpclient
    • The main idea on what I suggested is that you completely off-load the UI, so even if it takes the same time, this time will be taken on a background thread and your UI will keep running fast and smooth.
    • If this line of code has only caused the problem once or twice it may be time to look for a general memory usage problem.
    • Try to determine how close to the memory limit the application is.
    • Explore all reviews
  21. javax.xml.parsers
    • Almost the fastest.
    • 2nd slowest and fairly memory-intense, but necessary if you want/need the XML DOM to stick around in memory so you can operate on it.
    • Explore all reviews
  22. spring
    • Run it on Jetty...it will be light-weight!.
    • Hmm, I'm not sure, it looks like it expects to be deployed in a war file, and I would rather avoid a heavyweight servlet container and all of that infrastructure, the API is just a small part of my project, I don't want to stuff the entire thing in a war just so I can support the API :-/.
    • Explore all reviews
  23. com.google.appengine
    • My primary concern is having it be efficient, and after that, simple and elegant code.
    • It is stable and still actively developed, with version 2 has just been released couple of weeks ago.
    • Explore all reviews
  24. org.mongodb
    • If keys are numbers and values are numbers then it can be very compact in binary.
    • They are slow.
    • Explore all reviews
  25. com.extjs
    • I like to know which of these are best and more efficient in performance perspective and security.
    • As far as ExtJS being heavy, I think it's worth its weight in (...wait for it) time saved developing.
    • Explore all reviews
  26. com.googlecode.json-simple
    • You can use URL_https://code.google.com/p/json-simple/ [json-simple] its a high performance library and its very easy to use : CODESNIPPET_JAVA1 .
    • Which is annoying, because it means people then deviate from the standard without a problem, and wonder why they run into problems later when they use a stricter implementation.
    • You can use URL_https://code.google.com/p/json-simple/ [json-simple] its a high performance library and its very easy to use : CODESNIPPET_JAVA1 .
    • Which is annoying, because it means people then deviate from the standard without a problem, and wonder why they run into problems later when they use a stricter implementation.
    • A fast, simple, lightweight parser that I like is json-simple.
    • Explore all reviews
  27. net.sf.json-lib
    • Usually libraries like GSON or Jackson (mentioned above) offer some validations in this aspect avoiding mal-formed json input, and usually (I have worked with both) they do quite well on performance; also using a json lib would provide you with other functionality to extend in the future if you need.
    • Yeah, it is sometimes a pity when devs are too reluctant -- org.json package specifically is so primitive that using a proper JSON library (Gson, Jackson, json-lib) would simplify life a lot for most cases.
    • CODETERM3 provides a lot of performance benefits compared to the ordered alternatives, and hence is used more often in cases where ordering does not matter.
    • It comes down to the degree of flexibility you want, the performance you need, and whether you want a simple API or if you don't mind a more complex one.
    • Json-lib is sometimes easier to get to grasp with for smaller tasks that do not require top-speed, but with still completely acceptable results.Gson as also a good reputation and is very flexible, however the previous benchmarks I came across seemed to indicate that it did not perform as well as Jackson.
    • I've used URL_http://json-lib.sourceforge.net/ [JSONLib] , URL_http://flexjson.sourceforge.net/ [FlexJSON] and URL_http://code.google.com/p/google-gson/ [Gson] all with great success.
    • Explore all reviews
  28. javax.xml
    • The collect of phone numbers is of size 1 and is correctly bound by square brackets.
    • Since I am more familiar with Jackson, here are some aspects where I think Jackson has more complete support than Gson (apologies if I miss a Gson feature): Extensive annotation support; including full inheritance, and advanced "mix-in" annotations (associate annotations with a class for cases where you can not directly add them) Streaming (incremental) reading, writing, for ultra-high performance (or memory-limited) use cases; can mix with data binding (bind sub-trees) -- EDIT latest versions of Gson also include streaming reader Tree model (DOM-like access); can convert between various models (tree <-> java object <-> stream) Can use any constructors (or static factory methods), not just default constructor Field and getter/setter access (earlier gson versions only used fields, this may have changed) Out-of-box JAX-RS support Interoperability: can also use JAXB annotations, has support/work-arounds for common packages (joda, ibatis, cglib), JVM languages (groovy, clojure, scala) Ability to force static (declared) type handling for output Support for deserializing polymorphic types (Jackson 1.5) -- can serialize AND deserialize things like List correctly (with additional type information) Integrated support for binary content (base64 to/from JSON Strings) .
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • Explore all reviews
  29. com.google.gwt
    • Finally you can use CODETERM6 as well, but it can have some performance issues.
    • Slow iteration through a JSONArray in GWT.
    • (because it will not need any conversion for sending to server) And if i am using Json it will give good performance like java?
    • In GWT 2.1, CODETERM10 became deprecated and two more methods were introduced - CODETERM11 (uses CODETERM12 internally) and CODETERM13 (the safe approach).
    • I'm using GWT to build an application, and I'm facing serious speed issues with something that I thought would be pretty fast.
    • The minute is in development mode, but I don't know if it would be any faster when I compile it.
    • Explore all reviews
  30. net.sf.flexjson
    • I've seen some performance metrics on GSON - FlexJSON and Jackson Mapper are also easy to use APIs for converting POJO into JSON, and have better overall speed/performance than GSON.
    • By default it uses double if its a decimal and long if its an integer.
    • I want to go with Jackson because it is much faster than the alternatives, but I like FlexJSON the most.
    • Other than performance, there's URL_http://www.cowtowncoder.com/blog/archives/2010/11/entry_434.html [this- blog-post] ("7 Jackson killer features") that outlines what Jackson has to offer on its own (not considering integration with frameworks) -- other libraries have their own strengths, and for URL_http://flexjson.sourceforge.net/ [flex-json] I understand its output side (writing JSON) is quite flexible and powerful.
    • Try the URL_http://code.google.com/p/google-gson/ [GSon] from google and and URL_http://flexjson.sourceforge.net/ [FlexJson] Both are recommended .
    • Other than performance, there's URL_http://www.cowtowncoder.com/blog/archives/2010/11/entry_434.html [this- blog-post] ("7 Jackson killer features") that outlines what Jackson has to offer on its own (not considering integration with frameworks) -- other libraries have their own strengths, and for URL_http://flexjson.sourceforge.net/ [flex-json] I understand its output side (writing JSON) is quite flexible and powerful.
    • Explore all reviews
  31. com.google.code.gson
    • The power of GSON is not how fast it parses, but how fast it is to write and maintain the code required for a large number of production cases.
    • I believe this captures the spirit of JSON much better than a "manual parser" approach.
    • (addition to above: official numbers were included -- streaming Gson is faster than databinding, but not up to Jackson performance level).
    • My problem is more, if there is a structure issue somewhere in the json is there a way to "skip and continue" in GSON ?
    • I mean i have to create 10,000 java objects for 1000 json results.I am looking for super fast and memory efficient way to do it as json i get is very huge.
    • ^this, but would this method be faster/less costly?
    • Explore all reviews
  32. org.json
    • For my taste it is a bit less elegant than having a specific JsonException but if is not possible otherwise that is still good.
    • And answer is somewhat bogus too :).Json.org's lib is not efficient in any way (and light-weight only if you count size of code itself).
    • GSON is a very powerful library for convert JSON-Java Object and viceversa..
    • I'm reading the file into memory and parsing it using: CODESNIPPET_JAVA1 .
    • Too fast :( raaa.
    • 2 Extracted _invalid_ JSON string literal: "Apple Inc. (NASDAQ:AAPL) shares continued to lead large cap tech stocks in top performance this year.
    • Explore all reviews
  33. com.fasterxml.jackson
    • And with Jackson don't help me when I need to parse large files, so for my app GSON was the best, even more slow, can read large files.
    • Solve the out of memory problem.
    • I've seen some performance metrics on GSON - FlexJSON and Jackson Mapper are also easy to use APIs for converting POJO into JSON, and have better overall speed/performance than GSON.
    • The root cause it that your data is too large to be held in memory.
    • seems like jackson need them and gson doesn't right, this is a difference in performance.
    • I dont't know about performance compared to Jackson, but it's hard to be simpler than this... Gson is a stable and widely used library.
    • Explore all reviews
  34. org.codehaus.jettison
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • Two important notes: 1) This code is provided as-is; specifically I have not thoroughly tested it beyond my own limited use, and 2) The fact that this problem is virtually non-existent elsewhere on the internet, as well as the fact that this seems to be a relatively basic operation that Jettison should perform, strongly suggests to me that we're doing something fundamentally wrong and that this solution shouldn't be necessary.
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Note however that XStream really is an XML-based object serializer; so while it does have JSON compatibility support, it goes through JSON->XML converter (Jettison) so any size or performance benefits JSON may have are lost.
    • Explore all reviews
  35. org.springframework
    • I like to know which of these are best and more efficient in performance perspective and security.
    • The huge response object sits in memory and can't be GC'd until the last item has been handled.
    • I don't know enough about Spring to know about ModelAndView part, but I know enough about Jackson to say that the performance is unlikely to be problematic for Jackson filtering.One reason why filtering approaches are not trivially simple is because they try to balance usability with performance -- and as such, both JSON Views and Filters have very low overhead.
    • It's reasonably fast, and has good documentation.
    • JSON seem to be a lightweight and effective message container for us.
    • Explore all reviews
  36. com.google.protobuf
    • One last note : The object mapper is thread safe and having one static instance like in the example I just submitted will prevent you from having the slight instantiation overhead.
    • Actually, I disagree on your "scalability" and "maintenace" / "change" points re protobuf: protobuf is specifically designed for scalability, with dense output (smaller than json etc), and cheap processing (especially compared to text protocols).
    • Protobuf is very handy, and is designed to be highly performant (cheaper to process, smaller output) and very version tolerant but browsers are better at processing JSON.
    • performant and efficient data transfer.
    • The advantage of CODETERM5 is, that is fairly efficient compared to CODETERM6 and well accepted.
    • Explore all reviews
  37. org.zeromq
    • Replace the raw sockets with, at least, [ZeroMQ]( URL_http://www.zeromq.org /) if nothing more robust.
    • Explore all reviews
  38. javax.jms
  39. json-p
    • If so can get a 200 but if not CORS enabled or setup for jsonp will not trigger success.
    • Explore all reviews
  40. kryo
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • Explore all reviews
  41. net.sf.spring-json
  42. org.jboss
    • i would like to using only JAXB(native for JBOSS AS 7) for best performance, avoiding others "jar".
    • i would like to using only JAXB(native for JBOSS AS 7) for best performance, avoiding others "jar".
    • Explore all reviews
  43. resteasy
    • I have used both Jackson and Gson for the JSON support with RESTEasy and it is quite simple.
    • Explore all reviews
  44. json-smart
    • If you want to keep JSON, look for other frameworks like "json-smart": URL_http://code.google.com/p/json-smart/ [ URL_http://code.google.com/p/json - smart/] They claim to be 2-3 times faster than Jackson.
    • Explore all reviews
  45. org.hibernate
    • it is more efficient from a bandwidth perspective to exlucde certain large data properties.
    • Explore all reviews
  46. aalto-xml
    • ); but for async nothing yet that I am aware of.The lib you refer to seems badly named; it does not seem to do real asynchronous processing, but merely allow one to parse sequence of JSON documents (which multiple other libs allow doing as well) If there were people who really wanted this, writing one is not impossible -- for XML there is URL_http://wiki.fasterxml.com/AaltoHome [Aalto] , and handling JSON is quite a bit simpler than XML.For what it is worth, there is actually URL_http://jira.codehaus.org/browse/JACKSON-39 [this-feature-request] to add non-blocking parsing mode for URL_http://jackson.codehaus.org [Jackson] ; but very few users have expressed interest in getting that done (via voting for the feature request).
    • Explore all reviews
  47. neo4j-graphdb
    • Check out URL_http://neo4j.org/ [neo4J] The internal representation of the graph would be then delegated to the database and people have been working on this for years, so I would expect the representation to be efficient and performant.
    • Explore all reviews
  48. genson
    • However main advantages of Genson are : faster then Gson, more usefull features and is more flexible (you can add yourself new features in a more easy way).
    • Compared to Jackson it is more a matter of vision, jackson tries to handle a lot of cases but by making extension really hard, Genson takes another approach
    • provide nice features but stay open to extension.
    • This will work on Jackson as well as many other Java JSON libs (Gson, Genson at least), and will also be faster method to use.
    • Its performances were not good (especially compared to Jackson or Genson).With the latest versions it has improved as they also provide a streaming api, but its still not fast enough.
    • Actually Genson is faster and has more features than Gson and has performances close to jackson (but its a lot more lightweight) see URL_http://code.google.com/p/genson/wiki/Metrics [ URL_http://code.google.com/p/genson/wiki/Metrics ] .
    • Explore all reviews
  49. stax
    • It gives you the ease of XPath with the performance of STAX parsing; honestly (I am being unbiased, seriously) -- it is awesome.
    • It's URL_http://www.thebuzzmedia.com/software/simple-java-xml-parser- sjxp/#performance [really-fast] and it works on Android.
    • Explore all reviews
  50. org.boon
    • It compares Boon, Jackson, Smart JSON and GSON.
    • At times Boon is 4x faster.
    • :)GSON is better than most at I/O, but Boon does best all around (and best at I/O), and it has an index overlay mode that is even faster (look at the second set.. the index overlay puts Boon way over the top).
    • Boon is wicked fast.
    • Explore all reviews
  51. java.io
    • Obviously it depends on the average line size of the output, but that could very well be fewer batches than one per line.
    • Explore all reviews
  52. org.jboss.resteasy
    • GSON is indeed a very popular library, but for example, Jackson has a large installed base due to its inclusion as default JSON library in both RESTEasy and Jersey.
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Explore all reviews
  53. simple-http
    • In short, my purpose is to serve web services using JSON and HTTP Get/Post in a maximum possible lightweight solution.
    • Explore all reviews
  54. commons-jexl
    • By 'easily', I mean high level configuration API that would faster for me to use than to write my own expression evaluator.
    • Explore all reviews
  55. org.glassfish.main.core
  56. org.apache.cxf
    • JAX-RS is a java standard, Jackson library is fast and handles circular references and Apache CXF needs only a couple of lines of configuration to setup and start running.
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Explore all reviews
  57. io.gatling
    • Give boon a try: URL_https://github.com/RichardHightower/boon [ URL_https://github.com/RichardHightower/boon ] It is wicked fast: URL_https://github.com/RichardHightower/json-parsers-benchmark [ URL_https://github.com/RichardHightower/json-parsers-benchmark ] Don't take my word for it... check out the gatling benchmark.
    • It also has a index overlay mode that is even faster.
    • It can parse JSON to Maps and Lists faster than any other lib can parse to a JSON DOM and that is without Index Overlay mode.
    • It also has a very fast JSON lax mode and a PLIST parser mode.
    • Explore all reviews
  58. quick-json
    • You can prefer quick-json parser to meet your requirement... quick-json parser is very straight forward, flexible, very fast and customizable.
    • URL_https://code.google.com/p/quick-json/ [quick-json-parser] is very straight forward, flexible, very fast and customizable.
    • Explore all reviews
  59. org.neo4j
    • Check out URL_http://neo4j.org/ [neo4J] The internal representation of the graph would be then delegated to the database and people have been working on this for years, so I would expect the representation to be efficient and performant.
    • Explore all reviews
  60. jbutterfly
    • Replace the raw sockets with, at least, [ZeroMQ]( URL_http://www.zeromq.org /) if nothing more robust.
    • Explore all reviews
  61. org.msgpack
    • You should consider using MessagePack as it is full compatible with Redis and Lua, it is a great compression on JSON: URL_http://msgpack.org/ [ URL_http://msgpack.org/ ] It implies some Lua code to compress and uncompress, but the cost should be small.
    • Explore all reviews
  62. apache-io
    • I was just hoping for some other solution as doing something like this kinda defeats the performance benefits of using the streaming parser.
    • Explore all reviews
  63. thrift-protobuf-compare
    • EDIT: I guess i'm looking for what produces smaller files and operates faster.
    • One thing that might be interesting wrt Jackson is the performance aspect (Jackson is specifically designed as a very high performance JSON package), see [ URL_http://code.google.com/p/thrift-protobuf-compare/wiki/Benchmarking ] and [ URL_http://www.cowtowncoder.com/blog/archives/2009/09/entry_326.html ].
    • Explore all reviews
  64. jetty
    • Infact jetty or netty can support higher load, high number of connections etc.
    • Any performance tip or special configuration for Jetty?
    • It would be important if the processing of the messages (parsing and creating) would be easy and fast on both server and client side since the application should feature real time speed.
    • Explore all reviews
  65. io.netty
    • Infact jetty or netty can support higher load, high number of connections etc.
    • Explore all reviews
  66. org.mvel
    • By 'easily', I mean high level configuration API that would faster for me to use than to write my own expression evaluator.
    • Explore all reviews
  67. piccolo
  68. org.glassfish.jersey
    • GSON is indeed a very popular library, but for example, Jackson has a large installed base due to its inclusion as default JSON library in both RESTEasy and Jersey.
    • And voil!
    • Also, even without knowing this, users often ditch jettison as soon as they have tried Jackson ("pure" JSON) approach, and I think CXF also supports Jacksons (Jersey and RESTeasy do for sure).
    • Explore all reviews
  69. cassandra
    • In Cassandra, writes are much more efficient than reads so it is beneficial to avoid reads before writes if possible.
    • Explore all reviews
  70. jdbchelper
  71. boon
    • Give boon a try: URL_https://github.com/RichardHightower/boon [ URL_https://github.com/RichardHightower/boon ] It is wicked fast: URL_https://github.com/RichardHightower/json-parsers-benchmark [ URL_https://github.com/RichardHightower/json-parsers-benchmark ] Don't take my word for it... check out the gatling benchmark.
    • It also has a index overlay mode that is even faster.
    • With Boon Index Overlay mode, it is even faster.
    • :) (and has a super low memory, direct from bytes mode with UTF-8 encoding on the fly).
    • It also has the fastest JSON to JavaBean mode too.
    • It is new, but if speed and simple API is what you are looking for, I don't think there is a faster or more minimalist API.
    • Explore all reviews
  72. restlet