Java Message System. Petr Adámek. April 11 th 2016

Transcription

1 Java Message System Petr Adámek April 11 th 2016

2 What is this presentation about Why and how to use asynchronous communication. How to use JMS (but not only JMS). Commons mistakes and bests practices when using asynchronous communication. How to design reliable asynchronous systems. Petr Adámek: Java Message System 2

3 What is this presentation not about Enterprise Integration Patterns. Enterprise Integration Platforms (Spring Integration, Apache Camel, Mule, etc.) Message-driven-beans (EJB) Spring JMS Protocols (e.g. AMQP) Petr Adámek: Java Message System 3

4 Why Asynchronous Communication? Petr Adámek: Java Message System 4

5 JMS versus synchronous WS source system (Web Shop) Synchronous WS target system (Ordering System) source system (Web Shop) Asynchronous JMS Queue target system (Ordering System) Petr Adámek: Java Message System 5

6 JMS versus synchronous WS Aspect / Situation Synchronous WS Asynchronous JMS Queue Operation in target system take some time Result availability Threads utilization Target system is overloaded (Scalability) Target system is down or the network connection is not stable (Reliability) Source system is waiting for the response Result is available in calling thread Thread in source system is blocked until the operation in target system is finished Source system is waiting for the response, timeout can happen Source system get timeout or error Calling system does not need to wait for a response Result must be sent back asynchronously Thread in source system is block only until the message is saved Message is waiting in the queue and it is processed later Message is waiting in the queue and it is processed later Petr Adámek: Java Message System 6

7 JMS versus synchronous WS Pros Source system does not need to wait for response from target system. Source system does not depend on availability and load of target system. Better performance, scalability and reliability. Cons You need MQ provider Not well suitable for public internet API You don't have the immediate result Petr Adámek: Java Message System 7

8 Basic Rule Don't use synchronous WS for exchange of information which can be exchanged asynchronously Avoid The Hammer Syndrome When you hold a hammer, each problem looks like a nail. Petr Adámek: Java Message System 8

9 Introduction to JMS Petr Adámek: Java Message System 9

10 JMS Java Message Service API for asynchronous messaging in Java JMS 1.0.2b (June 26, 2001) JMS 1.1 (April 12, 2002, JSR 914, J2EE 1.4) JMS 2.0 (May 21, 2013, JSR 343, Java EE 7) Only API, no protocol, provides compatibility, but does not guarantee interoperability Interoperability depends on broker, which protocols, client APIs for other languages, or client libraries are supported, or if there is any suitable bridge. Petr Adámek: Java Message System 10

11 AMQP Advanced Message Queuing Protocol Protocol for asynchronous messaging AMQP 0-8 (Jun 2006), 0-9 (Dec 2006), 0-10 (Feb 2008), (Nov 2008) significantly different from AMQP 1.0. AMQP 1.0 (Oct 30, 2011); OASIS AMQP 1.0 (Oct 31, 2012); ISO/IEC (Apr 2014) Only protocol, no API (yet?), provides cross-platform interoperability, but does not guarantee compatibility. Compatibility can be provided by some high level API (Spring AMQP), by Enterprise Integration framework (Camel, Spring Integration) or if broker supports JMS. Petr Adámek: Java Message System 11

12 JMS versus AMQP JMS is API independent on specific wire protocol, you can change JMS broker without changing your code. AMQP is API and broker agnostic protocol, you can communicate across heterogeneous systems, using different languages, platforms and technologies. Can we take advantages of both technologies? Yes, many of brokers supports both JMS and AMQP. However they are some overlaps and differences (routing, message model and message structure). See Mark Richards: Understanding the Differences between AMQP & JMS. Petr Adámek: Java Message System 12

13 Other protocols STOMP Streaming Text Oriented Messaging Protocol Simple text-based protocol XMPP Extensible Messaging and Presence Protocol MQTT lightweight publisher-subscriber protocol. ISO/IEC PRF OpenWire Proprietary protocol of ActiveMQ Petr Adámek: Java Message System 13

14 Some JMS implementations Apache ActiveMQ ActiveMQ (JMS 1.1, AMQP 1.0) ActiveMQ Artemis (JMS 2.0, AMQP 1.0) Apache Qpid Qpid client (JMS 1.1, AMQP 0-9-1) Qpid JMS (JMS 1.1, AMQP 1.0, AMQP 0-9-1) RabbitMQ RabbitMQ (AMQP 0-9-1, AMQP 1.0 via plug in) Pivotal RabbitMQ (JMS 1.1, AMQP 0-9-1, AMQP 1.0) commercial product, JMS has some limitations. Petr Adámek: Java Message System 14

15 Some JMS implementations Oracle WebLogic WebLogic 11g (Java EE 5, JMS 1.1) WebLogic 12c (Java EE 6, JMS 1.1) WebLogic 12c (Java EE 7, JMS 2.0) Petr Adámek: Java Message System 15

16 Supported JMS and Protocols Product JMS AMQP STOMP MQTT Other ActiveMQ OpenWire ActiveMQ Artemis OpenWire RabbitMQ (*) 1.0 Pivotal RabbitMQ (*) 1.0 Qpid JMS (*) Qpid java (*) WebLogic 11g WebLogic 12c WebLogic 12c Petr Adámek: Java Message System 16

17 JMS Alternatives Asynchronous WS JAX-WS Service should be accessible from the Internet, Proprietary API of given broker Independent API JMS API extension Petr Adámek: Java Message System 17

18 JMS Architecture Petr Adámek: Java Message System 18

19 JMS Architecture JMS Client Java program that send and receive messages Message used to communicate information between clients JMS Provider messaging system implementing JMS Destination channel for message exchange JMS Client Message Producer 1 Message Producer 2 Message Producer 3 JMS Provider Destination A Destination B JMS Client Message Consumer 1 Message Consumer 2 Message Consumer 3 Petr Adámek: Java Message System 19

20 JMS Destinations Petr Adámek: Java Message System 20

21 Destination Abstract representation of JMS channel Encapsulates a provider-specific address Standard destination types Queue (point-to-point) Topic (publisher-subscriber) Petr Adámek: Java Message System 21

22 Queue (point-to-point) Each message is always delivered to single consumer When there is no consumer, message is waiting in the queue. When there is multiple consumers, message is delivered to one (any) of them. Producer Consumer Petr Adámek: Java Message System 22

23 Queue Consuming time Producer Queue Consumer A msg #1 msg #2 msg #3 msg #4 msg #1 msg #3 msg #4 Consumer C msg #2 Consumer B Consumer D Each message is always delivered to exactly one consumer When there is no consumer available, message is waiting until some consumer will became available. msg #5 msg #5 producer consumer Petr Adámek: Java Message System 23

24 Topic (publisher-subscriber) Each message is delivered to all subscriptions If there is no subscription, message is dropped. Subscription 1 Publisher Subscription 2 Subscription 3 Petr Adámek: Java Message System 24

25 Unshared / Shared subscription Unshared subscription Only single consumer. All the messages in the subscription are delivered to that consumer. Message order is guaranteed. Shared subscription Multiple consumers allowed. Each message in the subscription is delivered to only one consumer. Paralelization, better througput, better availability. Petr Adámek: Java Message System 25

26 Non-Durable / Durable Subscription Non-Durable subscription Created automatically when first consumer is created. Deleted automatically when last consumer is closed. Durable subscription Created automatically when first consumer is created (some JMS providers may provide facilities to administratively configure durable subscriptions). Deleted explicitly by appropriate API call. When no consumer for this subscription exists, subscription is inactive and each incoming messages is stored until an consumer is created or message expires. Petr Adámek: Java Message System 26

27 Unshared Non-Durable Subscription time Producer Topic Consumer A msg #1 msg #2 msg #3 msg #4 msg #5 msg #1 msg #4 msg #5 Consumer C msg #1 msg #2 msg #5 Consumer B Consumer D Default subscription type Only one consumer. Subscription is created automatically when consumer is created. Subscription is deleted automatically when consumer is closed. producer consumer subscription Petr Adámek: Java Message System 27

28 Shared Non-Durable Subscription time Producer Topic Consumer A msg #1 msg #2 msg #3 msg #4 msg #1 msg #4 Consumer C msg #2 Consumer B Consumer D Multiple consumers. Subscription is created automatically when first consumer is created. Subscription is deleted automatically when last consumer is closed. msg #5 msg #5 producer consumer subscription Petr Adámek: Java Message System 28

29 Unshared Durable Subscription time Producer Topic Consumer A msg #1 msg #2 msg #3 msg #4 msg #5 msg #1 msg #2 msg #3 msg #4 msg #5 Consumer C msg #1 msg #2 msg #3 msg #4 msg #5 producer consumer subscription Consumer B Consumer D Only one consumer at given time. Subscription is persistent, when the consumer is closed, messages are stored and they are delivered, when a new consumer for the subscription is created. Petr Adámek: Java Message System 29

30 Shared Durable Subscription time Producer Topic Consumer A msg #1 msg #2 msg #3 msg #4 msg #5 msg #1 msg #3 msg #4 Consumer C msg #2 msg #5 producer consumer subscription Consumer B Consumer D Multiple simultaneous consumers supported. Subscription is persistent, when all consumers are closed, messages are stored and they are delivered, when a new consumer for the subscription is created. Petr Adámek: Java Message System 30

31 Subscription Identification Shared or durable subscription must be identified to recognize which subscription a consumer belongs to: Subscription name (set as parameter during creating consumer) Client identification (part of ConnectionFactory configuration or set with Connection.setClientID(String)) Subscription Type Subscription Name Client Identifier unshared non-durable N/A ignored shared non-durable mandatory optional unshared durable mandatory mandatory shared durable mandatory optional Petr Adámek: Java Message System 31

32 JMS API Petr Adámek: Java Message System 32

33 JMS API Basic classes ConnectionFactory, Destination, Message Classic API (JMS 1.1, JMS 2.0) Connection, Session, MessageConsumer, MessageProducer Simplified API (JMS 2.0) JMSContext, JMSConsumer, JMSProducer Legacy domain specific API (JMS 1.0, JMS 1.1, deprecated in JMS 2.0) QueueConnectionFactory, QueueConnection, TopicConnectionFactory, QueueSession, QueueSender, QueueReceiver, TopicConnection, TopicSession, TopicPublisher, TopicSubscriber. Petr Adámek: Java Message System 33

34 Connection Factory Entry point for sending or receiving messages using JMS provider Factory for Connection JMS Context (JMS 2.0) Petr Adámek: Java Message System 34

35 Classic API Petr Adámek: Java Message System 35

36 Simplified API Petr Adámek: Java Message System 36

37 How to get Destination instance As JNDI resource Standard and preffered way. createqueue(string) or createtopic(string) of JMSContext or Session Create Destination object with given name. Method does not create the physical queue or topic, only appropriate Destination instance! Create the instance directly with constructor Usable for testing or simple example. Makes the code dependent on specific implementation, do not use in production code. Petr Adámek: Java Message System 37

38 Get JMS resources with JNDI // Using JNDI API Context ctx = new InitialContext().lookup("java:/comp/env"); ConnectionFactory connectionfactory = (ConnectionFactory) ctx.lookup("jms/connectionfactory"); Queue requestqueue = (Queue) ctx.lookup("jms/requestqueue"); // = "jms/connectionfactory") private ConnectionFactory = "jms/requestqueue") private Queue requestqueue; Petr Adámek: Java Message System 38

39 Temporary Destinations Temporary queue or topic Can be created programatically by JMS API. Useful e.g. for receiving responses to our messages. Can be consumed only by the Connection that created it. Exists until JMS connection is closed or the destination is explicitely deleted. If you are working with temporary destinations, make sure that you are handling well the situation when the connection is closed and temporary destination does not exist anymore. Petr Adámek: Java Message System 39

40 Temporary Destinations ConnectionFactory connectionfactory =... // Clasic API Connection connection = connectionfactory.createconnection(); Session session = connection.createsession(); TemporaryQueue temporaryqueue = session.createtemporaryqueue(); TemporaryTopic temporarytopic = session.createtemporarytopic(); // Simplified API JMSContext context = connectionfactory.createcontext(); TemporaryQueue temporaryqueue = context.createtemporaryqueue(); TemporaryTopic temporarytopic = context.createtemporarytopic(); // Delete destinations when you don't need it anymore temporaryqueue.delete(); temporarytopic.delete(); Petr Adámek: Java Message System 40

41 Message Header (defined by JMS) Priority, destination, expiration, message id, delivery mode, timestamp, redelivered, etc. Properties (defined by application) Body(depends on message type) StreamMessage a stream of primitive values MapMessage a set of name-value pairs TextMessage a String ObjectMessage a Serializable Java object BytesMessage a stream of uninterpreted bytes. Petr Adámek: Java Message System 41

42 Producing Messages Petr Adámek: Java Message System 42

43 Produce message (Classic API) ConnectionFactory connectionfactory =... Destination destination =... Connection connection = connectionfactory.createconnection(); Session session = connection.createsession(); MessageProducer producer = session.createproducer(destination); // there are some producer parameter which can be set producer.setpriority(5); Message message = session.createtextmessage("msg"); // Send the message. When the call is finished, // message is safely passed for delivery producer.send(message); // Don't forget to release all resources // If you are using JMS 2.0, you can use try-with-resources messageproducer.close(); session.close(); connection.close(); Petr Adámek: Java Message System 43

44 Produce message (Simplified API) ConnectionFactory connectionfactory =... Destination destination =... try (JMSContext context = connectionfactory.createcontext()) { } Message message = context.createtextmessage("message Body"); // JMSProducer is lightweight object without close() method // and with support for method chaining to simplify the usage // by creating new producer for each message and configuring // it using builder pattern style context.createproducer(destination) // Send the message. When the call is finished, // message is safely passed for delivery.send(message); Petr Adámek: Java Message System 44

45 Consume message (Classic API) ConnectionFactory connectionfactory =... Destination destination =... Connection connection = connectionfactory.createconnection(); Session session = connection.createsession(); MessageConsumer consumer = session.createconsumer(destination); // Start to receive messages connection.start(); // Get the next message from the destination. If there is no // message available, wait for the next message max 1000 ms Message message = consumer.receive(1000); // Process the message System.out.println(message); // Don't forget to release all resources // If you are using JMS 2.0, you can use try-with-resources consumer.close(); session.close(); connection.close(); Petr Adámek: Java Message System 45

46 Consume message (Simplified API) ConnectionFactory connectionfactory =... Destination destination =... try (JMSContext context = connectionfactory.createcontext(); JMSConsumer consumer = context.createconsumer(destination)) { } // consumer is not lightweight object, close() must be called // Start to receive messages context.start(); // Get the next message from the destination. If there is no // message available, wait for the next message max 1000 ms Message message = consumer.receive(1000); // Process the message System.out.println(message); Petr Adámek: Java Message System 46

47 Topic Subscriptions (Classic API) ConnectionFactory connectionfactory =... Topic topic =... Connection connection = connectionfactory.createconnection(); Session session = connection.createsession(); // Unshared non-durable subscription MessageConsumer sharedconsumer = session.createconsumer(topic); // Shared non-durable subscription MessageConsumer sharedconsumer = session.createsharedconsumer( topic, "subscription-name"); // Unshared durable subscription (client id must be set!) MessageConsumer consumer = session.createdurableconsumer( topic, "subscription-name"); // Shared durable subscription MessageConsumer consumer = session.createshareddurableconsumer( topic, "subscription-name"); Petr Adámek: Java Message System 47

48 Topic Subscriptions (Simplified API) ConnectionFactory connectionfactory =... Topic topic =... JMSContext context = connectionfactory.createcontext(); // Unshared non-durable subscription JMSConsumer sharedconsumer = context.createconsumer(topic); // Shared non-durable subscription JMSConsumer sharedconsumer = session.createsharedconsumer( topic, "subscription-name"); // Unshared durable subscription (client id must be set!) JMSConsumer consumer = session.createdurableconsumer( topic, "subscription-name"); // Shared durable subscription JMSConsumer consumer = session.createshareddurableconsumer( topic, "subscription-name"); Petr Adámek: Java Message System 48

49 Asynchronous Message Handling Petr Adámek: Java Message System 49

50 Message Consuming Synchronous message consuming Client has to call receive method (examples above) Asynchronous message consuming Incoming message is automatically processed with MessageListener, registered at appropriate MesageConsumer or JMSConsumer. EJB Message Driven Bean Another way of asynchronous message processing Suggested way of message processing (if it is possible to use EJB) Petr Adámek: Java Message System 50

51 Consume message (Classic API) ConnectionFactory connectionfactory =... Destination destination =... MessageListener messagelistener = (Message message) -> { // Process the message System.out.println(message); }; Connection connection = connectionfactory.createconnection(); Session session = connection.createsession(); MessageConsumer consumer = session.createconsumer(destination); consumer.setmessagelistener(messagelistener); // Start to receive messages connection.start(); // Now you can do anything else in current thread, messages // are received asynchronously in background thread // When finished, stop to receive messages and release resources connection.stop(); consumer.close(); session.close(); connection.close(); Petr Adámek: Java Message System 51

52 Consume message (Simplified API) ConnectionFactory connectionfactory =... Destination destination =... MessageListener messagelistener = (Message message) -> { // Process the message System.out.println(message); }; JMSContext context = connectionfactory.createcontext(); JMSConsumer consumer = context.createconsumer(destination) consumer.setmessagelistener(messagelistener); // Start to receive messages context.start(); // Now you can do anything else in current thread, messages // are received asynchronously in background thread // When finished, stop to receive messages and release resources context.stop(); consumer.close(); context.close(); Petr Adámek: Java Message System 52

53 Message Producing Synchronous message producing Thread calling send(...) method is blocked until the message is safely passed for delivery. When the send() method is successfuly finished, message is safely passed for delivery. Asynchronous message producing (JMS 2.0) send() method returns control to calling thread immediately and message is send in background thread. Client is informed about the success or failure asynchronously with CompletionListener. Petr Adámek: Java Message System 53

54 Message Parameters Petr Adámek: Java Message System 54

55 Message Parameters Some parameters affecting how the message is delivered can be set Delivery Mode Message Priority Delivery Delay (JMS 2.0) Time To Live Warning! Delivery parameters must be set at MessageProducer or JMSProducer. Although there are appropriate methods also directly in the Message class, they are for use by JMS providers only. If you will try to use them, it will not work. Petr Adámek: Java Message System 55

56 Delivery Mode Defines how reliable way will be the message delivered PERSISTENT Message will be stored to persistent storage to guarantee that it will not be lost in case of failure. This is the default mode. NON_PERSISTENT Message is held only in memory, less overhead, but message can be lost. Must be set as parameter of MessageProducer.send(...) method or with MessageProducer.setDeliveryMode(int) method. Message.setJMSDeliveryMode(int) will not work! Petr Adámek: Java Message System 56

57 Set Delivery Mode (Classic API) ConnectionFactory connectionfactory =... Destination destination =... Connection connection = connectionfactory.createconnection(); Session session = connection.createsession(); MessageProducer producer = session.createproducer(destination); Message message = session.createtextmessage("msg"); // This will not work! message.setdeliverymode(deliverymode.non_persistent); // This is the right way how to set Delivery Mode producer.setdeliverymode(deliverymode.non_persistent); // Delivery Mode can be also set as a parameter of send( ) method producer.send(message, DeliveryMode.NON_PERSISTENT, Message.DEFAULT_PRIORITY, Message.DEFAULT_TIME_TO_LIVE); messageproducer.close(); session.close(); connection.close(); Petr Adámek: Java Message System 57

58 Set Delivery Mode (Simplified API) ConnectionFactory connectionfactory =... Destination destination =... try (JMSContext context = connectionfactory.createcontext()) { } Message message = context.createtextmessage("message Body"); // This will not work! message.setdeliverymode(deliverymode.non_persistent); context.createproducer(destination) // This is the right way how to set Delivery Mode.setDeliveryMode(DeliveryMode.NON_PERSISTENT); // Simplified API does not support to set Delivery Mode // as parameter of send( ) method.send(message); Petr Adámek: Java Message System 58

59 Reply-To Reply-To is standard JMS message attribute which allows to specify into which destination we want to receive response to our message. Message.setJMSReplyTo(Destination). Petr Adámek: Java Message System 59

60 Concurrecy in JMS Petr Adámek: Java Message System 60

61 Concurrency support in JMS Class in classic API Class in simplified API Supports concurrent use Creating costs Destination yes expensive ConnectionFactory yes expensive Connection N/A yes expensive Session JMSContext no cheap MessageProducer JMSProducer no cheap MessageConsumer JMSConsumer no cheap Petr Adámek: Java Message System 61

62 Single Session Single session == single thread. Single session == single transaction. Only single message can be being sent or received at some specific time by single session. When there are multiple asynchronous message consumers in single session, message listeners are never called simultaneously (calls are serialized). We can share common thread pool for receiving messages from multiple destinations. Petr Adámek: Java Message System 62

63 Message Order Petr Adámek: Java Message System 63

64 Message Order Message consumed by a session define a serial order (this is important form message acknowledge). Messages sent to single destination by single session are received in the order in which they were sent. With respect to other rules: Messages priority, Messages delivery time. Order is not preserved between messages with different Delivery Mode, NON_PERSISTENT messages could not be delivered at all in case JMS provider failure. See in JMS 2.0 spec Petr Adámek: Java Message System 64

65 Acknowledge Acknowledge modes DUPS_OK_ACKNOWLEDGE AUTO_ACKNOWLEDGE CLIENT_ACKNOWLEDGE Acknowledge() versus resume(). Transactions support Local transactions XA transactions Petr Adámek: Java Message System 65

66 Redelivering messages When the message is not properly acknowledge, JMS broker will try to deliver it again. Message.getJMSRedelivered() Error queues. Petr Adámek: Java Message System 66

67 Persistent Messages Handling Petr Adámek: Java Message System 67

68 When is message persisted Message with PERSISTENT delivery mode must be persisted before client is notified about success of send operations (before send method returns or before CompletionListener.onCompletion(Message) is called). Under standard circumstances, messages are written frequently, but they are never read. Petr Adámek: Java Message System 68

69 How message is persisted Message is persisted to some persistent store, usually Filesystem Database Weblogic 11g has File store and JDBC store Persistent store Has limited capacity Can be shared with other subsystems Has some performance costs Petr Adámek: Java Message System 69

70 To avoid problem with performance Keep the message as small as possible. Use NON_PERSISTENT delivery mode when possible. Don't forget to set quota on all destinations. Design the application to handle well ResourceAllocationException. WLSProducer can be configured to block thread which is trying to send message for specified time period. Petr Adámek: Java Message System 70

71 WLS Distributed Destinations Petr Adámek: Java Message System 71

72 Distributed Destination Types Uniform Distributed Queue Uniform Distributed Topic Weighted Distributed Queue Weighted Distributed Topic Petr Adámek: Java Message System 72

73 Uniform Distributed Queue Server S1 Server S2 Server S3 Producer Producer Producer WLS Domain Physical queue Physical queue Uniform Distributed Queue Q1 Physical queue Consumer Consumer Consumer Petr Adámek: Java Message System 73

74 Uniform Distributed Queue Consist of several physical queue uniform distributed queue members. Load balancing Forward_delay Connecting WLS JMS Queue from the client Petr Adámek: Java Message System 74

75 Uniform Distributed Topic Consist of several physical topics uniform distributed topic members. All messages are sent to all Topic members. Durable subscribers (DurableTopicSubscriber) cannot be created for distributed topics. However, you can still create a durable subscription on distributed topic member and the other topic members will forward the messages to the topic member that has the durable subscription. Petr Adámek: Java Message System 75

76 Proprietary WLS JMS Extension avadocs/weblogic/jms/extensions/package-summary.ht ml Example in Fingerprints Petr Adámek: Java Message System 76

77 Selectors Petr Adámek: Java Message System 77

78 JMS and Spring Transaction handling Receiving messages Petr Adámek: Java Message System 78

79 Investigating the queue QueueBrowser JMX bean Petr Adámek: Java Message System 79

80 How to design reliable asynchronous systems Petr Adámek: Java Message System 80

81 Message Queues Advantages of message queues: Asynchronous: Queue it now, run it later. Decoupling: Separates application logic. Resilience: Won't take down your whole application if part of it fails. Redundancy: Can retry jobs if they fail. Guarantees: Makes sure that jobs will be processed. Scalable: Many workers can process individual jobs in a queue. Profiling: Can aid in identifying performance issues. Disadvantages of message queues: Asynchronous: you have to wait until a job is complete. Load: each job in the queue must wait its turn before it can be processed. If one job overruns, it affects each subsequent job. Architecture: the application needs to be designed with queues in mind. Petr Adámek: Java Message System 81

82 Petr Adámek: Java Message System 82

83 Questions? Petr Adámek: Java Message System 83