{"id":42,"date":"2016-05-06T08:56:05","date_gmt":"2016-05-06T08:56:05","guid":{"rendered":"http:\/\/symbioticindia.in\/docu\/?p=42"},"modified":"2016-05-06T08:56:05","modified_gmt":"2016-05-06T08:56:05","slug":"exposing-openjms-to-php","status":"publish","type":"post","link":"http:\/\/symbioticindia.in\/docu\/2016\/05\/06\/exposing-openjms-to-php\/","title":{"rendered":"Exposing OpenJMS to PHP"},"content":{"rendered":"\n\n\n
\n

Introduction<\/strong><\/p>\n

I recently got involved in a project where reliable communication between etherogenous platforms was required. Having already worked with JMS, I had to find a way to expose its services to the frontend(a PHP base web application). Some time before I had come across XFire, and had been looking for a chance to work on it. This was that chance.
\nI know SOAP can sometimes be cumbersome, but XFire really makes its use easy, and PHP well supports it( we’ll use the nusoap library).
\nIn this article I’ll make an introduction on how to easily merge together OpenJMS,XFire and PHP to get a generic, immediately usable messaging system.
\nIf someone will be interested in it, further articles will follow on this topic.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n


\nOverview<\/strong>
\nTo make this as simple as possible, I’m going to cover not a line more than what is really needed to achieve our goal, so just a few words about the involved technologies.<\/p>\n

JMS (java message service) is :”a messaging standard that allows application components based on the Java 2 Platform, Enterprise Edition (J2EE) to create,send, receive, and read messages. It enables distributed communication that is loosely coupled, reliable, and asynchronous<\/em>“(ref.<\/a>).
\nWhat we need is a way to allow non-java technologies(in our case PHP) to access the functionalities exposed by JMS. This time we’ll use SOAP.<\/p>\n

SOAP(simple object access protocol) is :a protocol for exchanging XML-based messages over a computer network, normally using HTTP. SOAP forms the foundation layer of the Web services stack, providing a basic messaging framework that more abstract layers can build on. SOAP can be used to facilitate a Service-Oriented architectural pattern <\/em>“(ref.<\/a>).<\/p>\n

Used platforms<\/strong><\/span>
\nThe JMS implementation we’re going to use is OpenJMS<\/a>. There are plenty of other valid JMS implementations; personally I find OpenJMS to be a good choice, is open source and easy to use .
\nSOAP services will be handled by XFire<\/a>, which allows us to expose even POJOs as web services at a snap.
\nPHP<\/a> will be our front end platform. The PHP part just handles soap calls, and it’s quite easy to adapt this part for other languages with soap extensions(basically every language has at least one).<\/p>\n

Before we start writing code<\/strong>
\nFirst thing to do is to download both OpenJMS(here<\/a>) and XFire(here<\/a>). From XFire we just need its libraries, but with OpenJMS we also need to start up the server. Nothing easier, we’re not going to configure anything. Unzip OpenJMS distribution and just start it(startup.sh or startup.bat) from its bin<\/em> directory.<\/p>\n

<\/span><\/p>\n

Writing the OpenJms functionalities wrapper<\/strong><\/h4>\n

We need to get\/post a message from\/to a queue\/topic. We have 4 combination, 2 for getting, 2 for posting.
\nLet’s first define an interface:<\/p>\n

<\/span><\/p>\n

\n
   1:<\/span>import<\/span> javax.jms.JMSException;\r\n   2:<\/span>import<\/span> javax.jms.TextMessage;\r\n   3:<\/span>import<\/span> javax.naming.NamingException;\r\n   4:<\/span>\r\n   5:<\/span>\/**<\/span>\r\n   6:<\/span> *<\/span>\r\n   7:<\/span> *<\/span> @author<\/span> beanizer<\/span>\r\n   8:<\/span> *\/<\/span>\r\n   9:<\/span>public<\/span> interface<\/span> OpenJMSService {<\/span>\r\n  10:<\/span>    public<\/span> TextMessage[] getMsgFromQueue<\/span>(String queue) throws<\/span> NamingException,\r\n                  JMSException;\r\n  11:<\/span>    public<\/span> TextMessage postMsgToQueue<\/span>(String queue,String msg) throws<\/span>\r\n                  NamingException,JMSException;\r\n  12:<\/span>\r\n  13:<\/span>    public<\/span> TextMessage[] getMsgFromTopic<\/span>(String topic,String consumer) throws<\/span>\r\n                  NamingException,JMSException;\r\n  14:<\/span>    public<\/span> TextMessage postMsgToTopic<\/span>(String topic,String msg) throws<\/span>\r\n                  NamingException,JMSException;\r\n  15:<\/span>    \r\n  16:<\/span>}<\/span> <\/span><\/pre>\n<\/div>\n
<\/p>\n
Note that:
\n1) We’re going to work only on text messages (more message types are available through JMS)
\n2) We’re not going to handle exceptions here. The thrown exceptions will be magically encapsulated by XFire and sent back to the client in the soap response
\n3) The interface will be used by XFire to build the SOAP wsdl and service.<\/p>\n
It’s now time to implement the concrete class:
\n<\/span><\/p>\n
\n
   1:<\/span>import<\/span> java.util.Hashtable;\r\n   2:<\/span>import<\/span> javax.jms.*;\r\n   3:<\/span>import<\/span> javax.naming.Context;\r\n   4:<\/span>import<\/span> javax.naming.InitialContext;\r\n   5:<\/span>import<\/span> javax.naming.NamingException;\r\n   6:<\/span>\r\n   7:<\/span>\/**<\/span>\r\n   8:<\/span> *<\/span>\r\n   9:<\/span> *<\/span> @author<\/span> beanizer<\/span>\r\n  10:<\/span> *\/<\/span>\r\n  11:<\/span>public<\/span> class<\/span> OpenJMSServiceImpl implements<\/span> OpenJMSService{<\/span>\r\n  12:<\/span>    Context context;\r\n  13:<\/span>    Session session;\r\n  14:<\/span>    Connection connection;\r\n  15:<\/span>    MessageConsumer receiver=<\/span>null<\/span>;\r\n  16:<\/span>    \/**<\/span> Creates<\/span> a<\/span> new<\/span> instance<\/span> of<\/span> OpenJMSServiceImpl<\/span> *\/<\/span>\r\n  17:<\/span>    public<\/span> OpenJMSServiceImpl<\/span>() {<\/span>\r\n  18:<\/span>        Hashtable properties =<\/span> new<\/span> Hashtable<\/span>();\r\n  19:<\/span>        properties.put<\/span>(Context.INITIAL_CONTEXT_FACTORY, \"<\/span>\r\n                  org.exolab.jms.jndi.InitialContextFactory<\/span>\"<\/span>);\r\n  20:<\/span>        properties.put<\/span>(Context.PROVIDER_URL, \"<\/span>tcp:\/\/localhost:3035\/<\/span>\"<\/span>);\r\n  21:<\/span>        try<\/span> {<\/span>\r\n  22:<\/span>            context =<\/span> new<\/span> InitialContext<\/span>(properties); \r\n  23:<\/span>            ConnectionFactory factory =<\/span>(ConnectionFactory)context.lookup<\/span>(\"<\/span>ConnectionFactory<\/span>\"<\/span>);\r\n  24:<\/span>            connection =<\/span> (Connection)factory.createConnection<\/span>();\r\n  25:<\/span>            session =<\/span> (Session)connection.createSession<\/span>(false<\/span>\r\n                  , Session.AUTO_ACKNOWLEDGE);\r\n  26:<\/span>            connection.start<\/span>();\r\n  27:<\/span>        }<\/span> catch<\/span> (Exception ex) {<\/span>\r\n  28:<\/span>            ex.printStackTrace<\/span>();\r\n  29:<\/span>        }<\/span>    \r\n  30:<\/span>        \r\n  31:<\/span>    }<\/span>\r\n  32:<\/span> <\/span><\/pre>\n<\/div>\n

\nHere we initialize a connection and a session to the OpenJMS server running on localhost at port 3035.
\nThe URL used on line 20 depends on the OpenJMS server configuration. We’re using the default, but keep in mind that OpenJMS could be on a different machine, different port, and could even use a different protocol(i.e. RMI).
\nWe’re using generic items for : ConnectionFactory,Connection and Session. Specific items for both topics and queues exist, but in this case we’re trying to simplify things.
\nOn line 25, the first parameter(false) tells that we’re not going to use a transactioned session.<\/p>\n
<\/span><\/p>\n
\n
  33:<\/span>    public<\/span> TextMessage[] getMsgFromTopic<\/span>(String topicName,String consumer) throws<\/span>\r\n                  NamingException,JMSException{<\/span>\r\n  34:<\/span>        Topic destination=<\/span>(Topic) context.lookup<\/span>(topicName);\r\n  35:<\/span>        try<\/span>{<\/span>\r\n  36:<\/span>            receiver=<\/span>session.createDurableSubscriber<\/span>(destination,consumer);\r\n  37:<\/span>        }<\/span> catch<\/span>(Exception ex){<\/span>}<\/span>\r\n  38:<\/span>        return<\/span> (getMsg<\/span>(receiver));\r\n  39:<\/span>    }<\/span>\r\n  40:<\/span>    public<\/span> javax.jms.TextMessage[] getMsgFromQueue<\/span>(String queueName) throws<\/span>\r\n                  NamingException,JMSException{<\/span>\r\n  41:<\/span>        Queue destination=<\/span>(Queue) context.lookup<\/span>(queueName);\r\n  42:<\/span>        MessageConsumer receiver=<\/span>session.createConsumer<\/span>(destination);\r\n  43:<\/span>        return<\/span> (getMsg<\/span>(receiver));\r\n  44:<\/span>\r\n  45:<\/span>    }<\/span>\r\n  46:<\/span>\r\n  47:<\/span>    \r\n  48:<\/span>    public<\/span> TextMessage postMsgToTopic<\/span>(String topicName, String msg) throws<\/span>\r\n                  NamingException,JMSException{<\/span>\r\n  49:<\/span>       Topic destination=<\/span> (Topic)context.lookup<\/span>(topicName); \r\n  50:<\/span>        MessageProducer sender =<\/span> session.createProducer<\/span>(destination); \r\n  51:<\/span>        return<\/span> postMsg<\/span>(sender,msg);\r\n  52:<\/span>    }<\/span>\r\n  53:<\/span>    \r\n  54:<\/span>    \r\n  55:<\/span>    public<\/span> TextMessage postMsgToQueue<\/span>(String queueName, String msg) throws<\/span>\r\n                  NamingException,JMSException{<\/span>\r\n  56:<\/span>        Queue destination=<\/span> (Queue)context.lookup<\/span>(queueName); \r\n  57:<\/span>        MessageProducer sender =<\/span> session.createProducer<\/span>(destination); \r\n  58:<\/span>        return<\/span> postMsg<\/span>(sender,msg);\r\n  59:<\/span>    }<\/span>\r\n  60:<\/span><\/pre>\n<\/div>\n

\nThe above snippet implements the 4 methods that will be exposed as SOAP methods.
\nAs you can see, message retrieving is demanded to the generic method “getMsg”(explained below), as the generic session created can be used by both topics and queues, so the specific methods just need to create a proper MessageConsumer.
\nSame thing for posting messages, a MessageProducer is created this time and passed to the generic function “postMsg”.
\nOn “getMsgFromTopic” we use an instance scoped MessageConsumer because a DurableSubscriber is valid at a session level, so we try to create it and if it already exists an (ignored) exception is thrown and trapped. Not very elegant…<\/p>\n
<\/span><\/p>\n
\n
  61:<\/span>\r\n  62:<\/span>    private<\/span> TextMessage postMsg<\/span>(MessageProducer sender, String msg) throws<\/span> \r\n                  JMSException{<\/span>\r\n  63:<\/span>        TextMessage   message =<\/span> session.createTextMessage<\/span>(msg);\r\n  64:<\/span>        sender.send<\/span>(message); \r\n  65:<\/span>        sender.close<\/span>();\r\n  66:<\/span>        return<\/span> message;\r\n  67:<\/span>    }<\/span>\r\n  68:<\/span>    \r\n  69:<\/span>    private<\/span> javax.jms.TextMessage[] getMsg<\/span>(MessageConsumer receiver) throws<\/span>\r\n                  JMSException{<\/span>\r\n  70:<\/span>        javax.jms.Message message=<\/span>receiver.receive<\/span>(100<\/span>);\r\n  71:<\/span>        TextMessage text=<\/span> (message instanceof<\/span> TextMessage) ?\r\n                  (TextMessage) message : null<\/span>;\r\n  72:<\/span>        javax.jms.TextMessage[] msgs=<\/span>{<\/span>text}<\/span>;\r\n  73:<\/span>        return<\/span> (msgs);\r\n  74:<\/span>    }<\/span>    \r\n  75:<\/span>\r\n  76:<\/span>}<\/span><\/pre>\n<\/div>\n
These are the generic methods we were talking about. They just post\/retrieve a message. In both cases a text message(the received or the sent) is passed back to the caller.
\nOn “getMsg” I’m using a TextMessage array as return type to make the function compatible with an eventual multi message retrieving method.<\/p>\n
This is a very basic implementation, lots of things are missing and other should be considered(finalizing, closing sessions\/connections etc.), but it’s maybe good enough as a starting point.
\nLet’s go on with the XFire section now.<\/p>\n
Exposing the service via XFire<\/strong><\/h4>\n
The following simple class is everything we need to expose our OpenJMSService<\/em> interface as a SOAP service through XFire.<\/p>\n
<\/span><\/p>\n
   1:<\/span>\r\n   2:<\/span>import<\/span> org.codehaus.xfire.XFire;\r\n   3:<\/span>import<\/span> org.codehaus.xfire.XFireFactory;\r\n   4:<\/span>import<\/span> org.codehaus.xfire.client.XFireProxyFactory;\r\n   5:<\/span>import<\/span> org.codehaus.xfire.server.http.XFireHttpServer;\r\n   6:<\/span>import<\/span> org.codehaus.xfire.service.Service;\r\n   7:<\/span>import<\/span> org.codehaus.xfire.service.binding.ObjectServiceFactory;\r\n   8:<\/span>import<\/span> org.codehaus.xfire.service.invoker.BeanInvoker;\r\n   9:<\/span>\r\n  10:<\/span>\/**<\/span>\r\n  11:<\/span> *<\/span>\r\n  12:<\/span> *<\/span> @author<\/span> beanizer<\/span>\r\n  13:<\/span> *\/<\/span>\r\n  14:<\/span>public<\/span> class<\/span> Main {<\/span>\r\n  15:<\/span>    XFireHttpServer server;\r\n  16:<\/span>    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args) {<\/span>\r\n  17:<\/span>        Main starter =<\/span> new<\/span> Main<\/span>();\r\n  18:<\/span>        try<\/span> {<\/span>\r\n  19:<\/span>            starter.start<\/span>();\r\n  20:<\/span>        }<\/span> catch<\/span> (Exception ex) {<\/span>\r\n  21:<\/span>            ex.printStackTrace<\/span>();\r\n  22:<\/span>        }<\/span>\r\n  23:<\/span>    }<\/span>\r\n  24:<\/span>    public<\/span> void<\/span> start<\/span>() throws<\/span> Exception\r\n  25:<\/span>    {<\/span>\r\n  26:<\/span>        \/\/<\/span> Create<\/span> an<\/span> XFire<\/span> Service<\/span>\r\n  27:<\/span>        ObjectServiceFactory serviceFactory =<\/span> new<\/span> ObjectServiceFactory<\/span>();\r\n  28:<\/span>        XFire xfire =<\/span> XFireFactory.newInstance<\/span>().getXFire<\/span>();\r\n  29:<\/span>        \r\n  30:<\/span>        Service service =<\/span> serviceFactory.create<\/span>(OpenJMSService.class<\/span>);\r\n  31:<\/span>        service.setInvoker<\/span>(new<\/span> BeanInvoker<\/span>(new<\/span> OpenJMSServiceImpl<\/span>()));\r\n  32:<\/span>        xfire.getServiceRegistry<\/span>().register<\/span>(service);\r\n  33:<\/span>        \r\n  34:<\/span>        \/\/<\/span> Start<\/span> the<\/span> HTTP<\/span> server<\/span>\r\n  35:<\/span>        server =<\/span> new<\/span> XFireHttpServer<\/span>();\r\n  36:<\/span>        server.setPort<\/span>(8191<\/span>);\r\n  37:<\/span>        server.start<\/span>();\r\n  38:<\/span>    }<\/span>\r\n  39:<\/span>    public<\/span> void<\/span> stop<\/span>() throws<\/span> Exception\r\n  40:<\/span>    {<\/span>\r\n  41:<\/span>        server.stop<\/span>();\r\n  42:<\/span>    }<\/span>    \r\n  43:<\/span>}<\/span> <\/span><\/pre>\n
Xfire allows us to avoid the hassle of setting up a servlet engine, by providing an embedded http server(Jetty). The above code is pretty self-explaining; after creating an XFire object through a factory, we register a service (our OpenJMSService service) on it and just start the embedded http server. That’s all!!!
\nJust put in your classpath the required XFire and OpenJMS jars and launch our Main<\/em> class. Main.java, OpenJMSService.java and OpenJMSServiceImpl.java must reside in the same directory(you can arrange them differently in packages if you prefer).<\/p>\n
Now we can call our service with any SOAP client. Let’s see how to do it with PHP.<\/p>\n
<\/h4>\n
Accessing the SOAP service from PHP<\/strong><\/p>\n
First, from a system shell start OpenJMS admin GUI (admin.sh or admin.bat in bin<\/em>) and create a queue with name “myqueue” and a topic with name “mytopic” containig a consumer named “cons1”.
\nThe following simple class is everything we need to access our OpenJMSService<\/em> SOAP service from PHP.<\/p>\n
<\/span><\/p>\n
   1:<\/span><?php<\/span>\r\n   2:<\/span>        include_once<\/span>(\"<\/span>nusoap<\/span>.<\/span>php<\/span>\"<\/span>);<\/span>\r\n   3:<\/span>\r\n   4:<\/span>        class<\/span> OpenJms4PHP<\/span>{<\/span>\r\n   5:<\/span>                var<\/span> $<\/span>proxy<\/span>;<\/span>\r\n   6:<\/span>                var<\/span> $<\/span>params<\/span>;<\/span>\r\n   7:<\/span>                var<\/span> $<\/span>sess<\/span>;<\/span>\r\n   8:<\/span>                var<\/span> $<\/span>client<\/span>;<\/span>\r\n   9:<\/span>                \r\n  10:<\/span>                function<\/span> OpenJms4PHP<\/span>($<\/span>endpoint<\/span>){<\/span>\r\n  11:<\/span>                        $this<\/span>->client<\/span> =<\/span> new<\/span> soapclient<\/span>($<\/span>endpoint<\/span>,<\/span>true<\/span>);<\/span>\r\n  12:<\/span>                        $this<\/span>->proxy<\/span> =<\/span> $this<\/span>->client<\/span>->getProxy<\/span>();<\/span>\r\n  13:<\/span>                        \r\n  14:<\/span>                }<\/span>\r\n  15:<\/span>                function<\/span> PostMsgToQueue<\/span>($<\/span>queueName<\/span>,<\/span>$<\/span>msg<\/span>){<\/span>\r\n  16:<\/span>                        return<\/span> $this<\/span>->proxy<\/span>->PostMsgToQueue<\/span>(array<\/span>(\r\n                  \"<\/span>in0<\/span>\"<\/span>=<\/span>><\/span>$<\/span>queueName<\/span>,<\/span>\"<\/span>in1<\/span>\"<\/span>=<\/span>><\/span>$<\/span>msg<\/span>));<\/span>\r\n  17:<\/span>                }<\/span>\r\n  18:<\/span>                function<\/span> PostMsgToTopic<\/span>($<\/span>topicName<\/span>,<\/span>$<\/span>msg<\/span>){<\/span>\r\n  19:<\/span>                        return<\/span> $this<\/span>->proxy<\/span>->PostMsgToTopic<\/span>(array<\/span>(\r\n                  \"<\/span>in0<\/span>\"<\/span>=<\/span>><\/span>$<\/span>topicName<\/span>,<\/span>\"<\/span>in1<\/span>\"<\/span>=<\/span>><\/span>$<\/span>msg<\/span>));<\/span>\r\n  20:<\/span>                }<\/span>               \r\n  21:<\/span>                function<\/span> getMsgFromTopic<\/span>($<\/span>topicName<\/span>,<\/span>$<\/span>consumerName<\/span>){<\/span>\r\n  22:<\/span>                        return<\/span> $this<\/span>->proxy<\/span>->getMsgFromTopic<\/span>(array<\/span>(\r\n                  \"<\/span>in0<\/span>\"<\/span>=<\/span>><\/span>$<\/span>topicName<\/span>,<\/span>\"<\/span>in1<\/span>\"<\/span>=<\/span>><\/span>$<\/span>consumerName<\/span>));<\/span>\r\n  23:<\/span>                }<\/span>               \r\n  24:<\/span>                function<\/span> getMsgFromQueue<\/span>($<\/span>queueName<\/span>){<\/span>\r\n  25:<\/span>                        return<\/span> $this<\/span>->proxy<\/span>->getMsgFromQueue<\/span>(array<\/span>(\r\n                  \"<\/span>in0<\/span>\"<\/span>=<\/span>><\/span>$<\/span>queueName<\/span>));<\/span>\r\n  26:<\/span>                }<\/span>               \r\n  27:<\/span>                \r\n  28:<\/span>        }<\/span>\r\n  29:<\/span>?><\/span> <\/span><\/pre>\n

\nNusoap is an excellent soap library for PHP. PHP5 includes its own soap classes. You can use them if you prefer, only minimal changes are needed.
\nAfter creating a soap object, we retrieve the proxy, and just call the exposed methods. We’ll get back an array containing the returned object, which can also be an error.<\/p>\n
Here a simple example of usage:<\/p>\n
<\/span><\/p>\n
   1:<\/span><?php<\/span>\r\n   2:<\/span>        include_once<\/span> \"<\/span>OpenJms4PHP.php<\/span>\"<\/span>;<\/span>\r\n   3:<\/span>        $jms<\/span>=<\/span>new<\/span> OpenJms4PHP<\/span>(\"<\/span>http<\/span>:<\/span>\/<\/span>\/<\/span>127<\/span>.<\/span>0<\/span>.<\/span>0<\/span>.<\/span>1<\/span>:<\/span>8191<\/span>\/<\/span>OpenJMSService<\/span>?<\/span>wsdl<\/span>\"<\/span>);<\/span>\r\n   4:<\/span>        $<\/span>result<\/span>=<\/span>$jms<\/span>->PostMsgToTopic<\/span>(\"<\/span>mytopic<\/span>\"<\/span>,<\/span>\"<\/span>PHP2OpenJMSService<\/span> test<\/span> message<\/span>\"<\/span>);<\/span>\r\n   5:<\/span>        echo<\/span> \"<\/span><<\/span>pre<\/span>><\/span>\"<\/span>;<\/span>\r\n   6:<\/span>        print_r<\/span>($<\/span>result<\/span>);<\/span>\r\n   7:<\/span>        echo<\/span> \"<\/span><<\/span>\/<\/span>pre<\/span>><\/span>\"<\/span>;<\/span>\r\n   8:<\/span>?><\/span> <\/span><\/pre>\n
<\/p>\n
The URL passed to the contructor of OpenJms4PHP is the XFire server one (on localhost and port 8191, the default).<\/p>\n
Conclusions<\/strong>
\nWith an interface, 2 small java classes and a PHP script, we’ve built the (still incomplete) root for a trivial to use messaging system.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
Introduction I recently got involved in a project where reliable communication between etherogenous platforms was required. Having already worked with JMS, I had to find a way to expose its services to the frontend(a PHP base web application). Some time before I had come across XFire, and had been looking for a chance to work ..<\/p>\n
<\/div>\n
Read more<\/a><\/p>\n","protected":false},"author":5,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5,9,6],"tags":[],"class_list":["post-42","post","type-post","status-publish","format-standard","hentry","category-java","category-jms","category-php"],"_links":{"self":[{"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/posts\/42","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/comments?post=42"}],"version-history":[{"count":1,"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/posts\/42\/revisions"}],"predecessor-version":[{"id":43,"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/posts\/42\/revisions\/43"}],"wp:attachment":[{"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/media?parent=42"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/categories?post=42"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/symbioticindia.in\/docu\/wp-json\/wp\/v2\/tags?post=42"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}