<div class="wiki-content maincontent"><h1>Books</h1><p>This page lists the known books about Apache ActiveMQ. If you happen to know a book which is not listed then please contact us, for example using the <link><page ri:content-title="Mailing Lists"></page></link>.</p><ul><li><a shape="rect" href="http://bit.ly/2je6cQ">ActiveMQ in Action</a></li><li><a shape="rect" href="http://goo.gl/RFltj">Instant Apache ActiveMQ Messaging Application Development</a></li><li><a shape="rect" href="http://shop.oreilly.com/product/0636920032366.do">Mobile and Web Messaging</a></li><li><a shape="rect" href="http://www.ttmsolutions.com/Apache_Software/ActiveMQ_Reference_Guide.php">Apache ActiveMQ Reference Guide</a></li></ul><h3>ActiveMQ in Action</h3><p><a shape="rect" href="http://bit.ly/2je6cQ">ActiveMQ in Action</a> by <a shape="rect" href="http://bruceblog.org/">Bruce Snyder</a>, <a shape="rect" href="http://www.nighttale.net/">Dejan Bosanac</a> and <a shape="rect" href="http://rajdavies.blogspot.com/">Rob Davies</a>. Published by <a shape="rect" href="http://www.manning.com">Manning</a>.</p><p><a shape="rect" href="http://bit.ly/2je6cQ"><image><url ri:value="http://www.manning.com/snyder/snyder_cover150.jpg"></url></image></a></p><p>Apache ActiveMQ in Action is a thorough, practical guide to implementing message-oriented systems in Java using ActiveMQ. The book lays out the core of ActiveMQ in clear language, starting with the anatomy of a JMS message and moving quickly through connectors, message persistence, authentication and authorization. With the basics well in hand, you move into interesting examples of ActiveMQ at work, following a running Stock Portfolio application. You'll integrate ActiveMQ with containers like Geronimo and JBoss and learn to tie into popular Java-based technologies like Spring Framework.</p><p>Along the way, you'll pick up best practices forged out of the deep experience the authors bring to the book. You'll learn to integrate with non-Java technologies and explore advanced topics like broker topologies and configuration and performance tuning.</p><h3>Instant Apache ActiveMQ Messaging Application Development</h3><p><a shape="rect" href="http://goo.gl/RFltj">Instant Apache ActiveMQ Messaging Application Development</a> by <a shape="rect" href="http://timbish.blogspot.com/">Timothy Bish</a>. Published by <a shape="rect" href="http://www.packtpub.com/">Packt Publishing</a>.</p><p><a shape="rect" href="http://goo.gl/RFltj"><image><url ri:value="http://dgdsbygo8mp3h.cloudfront.net/sites/default/files/imagecache/productview_larger/9413OS.jpg"></url></image></a></p><p>Instant ActiveMQ Application Development How-to is for the developers who are new to Java Message Service application development or new to JMS development using ActiveMQ. Readers will come away ready to solve complicated messaging related problems using the JMS API and ActiveMQ.</p><p>Filled with practical, step-by-step instructions and clear explanations for the most important and useful tasks.This is a Packt Instant How-to guide, which provides concise and practical recipes to help you get started writing applications with ActiveMQ using practical examples.</p><h3>Mobile and Web Messaging</h3><p><a shape="rect" href="http://shop.oreilly.com/product/0636920032366.do">Messaging Protocols for Web and Mobile Devices by Jeff Mesnil. Published by OReilly.</a></p><p><image><url ri:value="http://akamaicovers.oreilly.com/images/0636920032366/cat.gif"></url></image></p><p>Learn how to use messaging technologies to build responsive and resilient applications for mobile devices and web browsers. With this hands-on guide, you&#8217;ll use the STOMP and MQTT messaging protocols to write iOS and web applications capable of sending and receiving GPS and device sensor data, text messages, and alerts.</p><h3>Apache ActiveMQ Reference Guide Kit</h3><p>The TTM's "<a shape="rect" href="http://www.ttmsolutions.com/Apache_Software/ActiveMQ_Reference_Guide.php">Apache ActiveMQ Reference Guide</a>" (PDF book) provides information to learn how to implement, deploy, administer, and tune Apache ActiveMQ. The Reference Guide includes details on how to work with ActiveMQ components, connectors, client/broker configuration, master/slave configuration, administration, logging, performance tuning and advanced features.</p></div>

