We're about to begin a project which requires the use of SMPP as the primary integration exchange channel. Now since SMS isn't necessarily core to our business, I'd like to use an SMPP library for Java that will be the least hassle. Aside from riding on the actual protocol, its unlikely we'll need fancier abilities or to ever tweak under the hood.
To that end, I've shortlisted some of the possible options that we have:
- Logica's Open SMPP
- Apache's Camel
- JSMPP
- Twitter's Cloudhopper
Can someone who's more experienced in their uses throw some of their experiences my way ?
EDIT: Just to give scope to the use cases, we'll be both sending and receiving SMS'es so the library should hopefully make life easy with both client action and also server listener implementation.
I have used both jsmpp & cloudhopper-smpp for separate projects which involved sending and receiving SMS's over smpp in circumstances which involved:
- Receiving medium-high number of MOs.
- Sending high number of MTs (upto 70/second).
Both the libraries fared well, and IMO jsmpp is more user-friendly to jump in and start coding right away. But i had came across a few bugs while using the latest version from github, which still remain unfixed.
After having used cloudhopper, i reckon it is well worth the learning curve, which is a wee bit steep compared to jsmpp(subjective).
Just an updated to what I finally decided (and how libraries reviewed):
Logica: Seems promising but I was concerned about the lack of updates/activeness of the community in general. The last meaningful build was yonks ago so not really an investment I wanted to make.
Apache Camel: We started off using this but there were some limitations to their library (we needed to insert custom heads to our SMPP packets). To be fair they were fairly prompt in responding to issues on their forums but their build cycles took a little too long for my sprints, so we scratched this.
JSMPP: This is the one we ended up using. Was pretty straightforward overall tho it did feel like it expected you to already have a fairly good idea of SMPP in general. Things are in staging so I can't tell you how it performs under production load. Will update when it goes live.
Cloudhopper: To be honest this was the one I was keen to use but more because like any geek I wanted to jump on the shiniest newest toy available. I didn't really get adequate responses to any queries we made from the off so was apprehensive to get on board. No reason to adopt a library that will require me to wade thru their codes when other more documented options were available.
I am currently implementing a SMPP solution over Java using Logica's library. It is very easy to use. The following information states the result of the tests:
Application: Enterprise Java Beans Application deployed in Glassfish 3.1.2.2
Language: Java (using JMS)
Library: Logica SMPP (version 1.3)
Origin (ESME): localhost
Destination (SMSC): Logica SMSC simulator at development server (hosted in Amazon Web Services)
Type: Transciever Asynchronous
Avg sending rate (80%): 246 msg / sec
Low sending rate (15%): 50 msg / sec
High sending rate (5%): 255 msg /sec
It is very efficient as long as you stick to the asynchronous mode. If you need to keep a correlation between the message and its response use the "sequence number" that is both in the message and the response.
Our SMSC was written on Logica SMPP (v 1.3), it still works really well with enterprise loadings. There has been only a few small issues regarding the library mainly with message_payload, honestly I don't remember other issues. But it's easy to repair because it's an opensource product.
Although I personally trust logica's sources, for small clients I use jsmpp. I agree with @Farhan that it's a bit more user friendly and developing of a simple client takes less time.
I've used both jsmpp and smppapi and found the latter much nicer because jsmpp had only synchronous blocking mode at that time (2010) - not sure if that's still the case.
The blocking nature of jsmpp become source of big problems when the SMPP server I was connecting to were experiencing some performance problems and responded slower than usual. Suddenly I found all of my threads to be waiting for responses. Migration to smppapi solved the problems obviously.
I've used Logica SMPP for a production project. It's not actively maintained anymore and there are a few inherent bugs which resulted in having to produce workarounds or actually forking the codebase to fix. Having said that, I've found the API to be very stable and performant (300msg/s).
I've briefly looked at JSMPP and it has a much nicer API than Logica although there seems to be a large number of defects have not been fixed despite there being on the issue list for a long time.
Just came across Cloudhopper SMPP which seems to be coded in a more up to date style but again it needs more examples. Having to chore through the code base is not attractive. Examples on gituhub are getting better though.
Cloudhopper is the best choice, Apache's Camel is also good but it's a very big project that has many interfaces to pdf, salesforce.... that you don't need. Other project is not updated to date. Cloudhopper is maintaining by Telestax and they add some useful features and look like they will give strong support it in future
Here's stack for easying config Cloudhopper https://github.com/RestComm/smpp-extensions Here's forked Cloudhopper by telestax (very up to date): https://github.com/RestComm/cloudhopper-smpp Also JainSlee Resource Adapter for whom who's working in telecom field https://github.com/RestComm/jain-slee.smpp
来源：https://stackoverflow.com/questions/14368611/java-smpp-library-comparison