Joomla! Documentation - User contributions [en]

JSON Responses with JResponseJson

2013-09-28T20:28:24Z

Chraneco: /* Additional Options */

{{version/tutor|3.x}}
== Overview ==

Recently a new class JResponseJson was added to Joomla! 3.x which is able to simplify things with Ajax requests. With that class it is now possible to prepare responses to Ajax requests in a standardized and easy manner. You can have a look at the file here:
https://github.com/joomla/joomla-cms/blob/master/libraries/cms/response/json.php
It will mostly be used in controllers of components where you get the following advantages:

* Using the flag 'success' the JavaScript code (whether Mootools JRequest.JSON or jQuery.getJSON) can check whether the task was successful or not and react accordingly (If the request itself failes the error event of the JavaScript API can be used).
* Then, the actual response data (if any) can be retrieved from 'data' in the JSON object and
* optionally a main response message from 'message'.
* Additionally, all gathered messages in the JApplication message queue are also automatically sent back in 'messages'. This can optionally be turned off.

Another advantage is that no $app->close(); is necessary anymore if the Ajax request is done with 'format=json' because the already existing API handles the rest. Just echo the response object at the end of the task.

== How to Use ==
=== Most Common Cases ===

Here is an example controller file:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$result = $this->getModel('example')->createSomething($anyParam);

echo new JResponseJson($result);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

As you can see in the default case the return value of something that has been calculated by the model is simply pushed into a new JResponseJson object and written to the output. This will automatically create a JSON encoded string as follows:

<source>
{"success":true,"message":null,"messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

So, in the 'data' field you can send any array, object or value you want and the 'success' flag is automatically set to 'true'.

If any exception occured in the model this exception is simply passed directly to a new JResponseJson object in our example which would create the following output:

<source>
{"success":false,"message":"This is the message of the exception","messages":null,"data":null}
</source>

Since it is an exception the 'success' flag was automatically set to 'false' and the message of the exception became the main response message.

=== Additional Options ===

If not an exception is passed as the first argument of the JResponseJson constructor you can specify an arbitrary main response message by passing a string as the second argument:
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_SUCCESS'));
</source>
which creates e.g.:
<source>
{"success":true,"message":"The request was successful.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can also manually set the error flag to 'false' with the help of the third argument ($error):
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_ERROR'), true);
</source>
which creates e.g.:
<source>
{"success":false,"message":"The was an error.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>
Please note that this way you can also send some data back.

Regardless of having an error response or a success response JResponseJson sends all messages back to the client that have been gathered in the application object:
<source lang="php">
$app = JFactory::getApplication();
// Some code ($result = ...)
$app->enqueueMessage('This part was successful');
// Some more code
$app->enqueueMessage('Here was a small warning'. 'warning');

echo new JResponseJson($result, 'Main response message');
</source>

This results in
<source>
{"success":true,"message":"Main response message","messages":"<<all the encoded messages of $app>>","data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can see the big advantage of that below in the JavaScript section.

If you don't want to send the messages back (rather that they stay in the session), simply set the fourth argument ($ignoreMessages) of the contructor to 'true'.

=== Corresponding JavaScript Code ===

Here is some sample JavaScript used which can be used on the client side together with JResponseJson on the server side.
The example is written with some Mootools code, but something similar can also be done with jQuery or any other JavaScript library for Ajax requests.

<source lang="javascript">
var req = new Request.JSON({
method: 'post',
url: 'index.php?option=com_component&task=mycontroller.execute&format=json',
onSuccess: function(r)
{
if (!r.success && r.message)
{
// Success flag is set to 'false' and main response message given
// So you can alert it or insert it into some HTML element
alert(r.message);
}

if (r.messages)
{
// All the enqueued messages of the $app object can simple be
// rendered by the respective helper function of Joomla!
// They will automatically be displayed at the messages section of the template
Joomla.renderMessages(r.messages);
}

if (r.data)
{
// Here you can access all the data of your response
alert(r.data.myfirstcustomparam);
alert(r.data.mysecondcustomparam);
}
}.bind(this),
onFailure: function(xhr)
{
// Reaching this point means that the Ajax request itself was not successful
// So JResponseJson was never called
alert('Ajax error');
}.bind(this),
onError: function(text, error)
{
// Reaching this point means that the Ajax request was answered by the server, but
// the response was no valid JSON (this happens sometimes if there were PHP errors,
// warnings or notices during the development process of a new Ajax request).
alert(error + "\n\n" + text);
}.bind(this)
});
req.post('anyparam=myvalue');
</source>

== Best Practice ==
As already seen above, code of the controller can be kept very simple using JResponseJson. The model is calculating the data which can be passed to JResponseJson afterwards (of course you can still modify it in the controller if you want to). If you are developing an MVC component you should save such a controller in a file called 'mycontroller.json.php' and place it inside your 'controllers' folder.
This way, that controller is automatically executed if your request URL contains 'format=json'.

Please note that as you can see in the example, there is no need for closing the application (e.g. $app->close();) because the architecture of Joomla! handles that for you. So, this is very clean and good programming.

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

echo new JResponseJson($count);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

===Additional Note===

If you want to support no-js users by for example doing the same task with a normal request and a final redirect back to the page, there is not much you have do additionally. Just create another controller (now with name 'mycontroller.php') and code like this:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
$app = JFactory::getApplication();
$app->setRedirect(JRoute::_('index.php?option=com_mycomponent&view=myview', false));

try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

$app->setMessage(JText::plural('COM_COMPONENT_COUNT_TASK', $count));
}
catch(Exception $e)
{
$app->setMessage(JText::sprintf('COM_COMPONENT_COUNT_TASK_ERROR', $e->getMessage()), 'error');
}
}
}</source>

No changes necessary in the model!

So depending on whether you do the request with 'format=json' (Ajax-Request) or via normal request (without 'format' parameter), the correct controller is executed automatically and the response is prepared accordingly.

[[Category:Extension development]]
[[Category:Component Development]]
[[Category:AJAX]]

JSON Responses with JResponseJson

2013-09-28T20:26:59Z

Chraneco: /* Most Common Cases */

{{version/tutor|3.x}}
== Overview ==

Recently a new class JResponseJson was added to Joomla! 3.x which is able to simplify things with Ajax requests. With that class it is now possible to prepare responses to Ajax requests in a standardized and easy manner. You can have a look at the file here:
https://github.com/joomla/joomla-cms/blob/master/libraries/cms/response/json.php
It will mostly be used in controllers of components where you get the following advantages:

* Using the flag 'success' the JavaScript code (whether Mootools JRequest.JSON or jQuery.getJSON) can check whether the task was successful or not and react accordingly (If the request itself failes the error event of the JavaScript API can be used).
* Then, the actual response data (if any) can be retrieved from 'data' in the JSON object and
* optionally a main response message from 'message'.
* Additionally, all gathered messages in the JApplication message queue are also automatically sent back in 'messages'. This can optionally be turned off.

Another advantage is that no $app->close(); is necessary anymore if the Ajax request is done with 'format=json' because the already existing API handles the rest. Just echo the response object at the end of the task.

== How to Use ==
=== Most Common Cases ===

Here is an example controller file:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$result = $this->getModel('example')->createSomething($anyParam);

echo new JResponseJson($result);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

As you can see in the default case the return value of something that has been calculated by the model is simply pushed into a new JResponseJson object and written to the output. This will automatically create a JSON encoded string as follows:

<source>
{"success":true,"message":null,"messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

So, in the 'data' field you can send any array, object or value you want and the 'success' flag is automatically set to 'true'.

If any exception occured in the model this exception is simply passed directly to a new JResponseJson object in our example which would create the following output:

<source>
{"success":false,"message":"This is the message of the exception","messages":null,"data":null}
</source>

Since it is an exception the 'success' flag was automatically set to 'false' and the message of the exception became the main response message.

=== Additional Options ===

If not an exception is passed as the first argument of the JResponseJson constructor you can specify an arbitrary main response message by passing a string as the second argument:
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_SUCCESS'));
</source>
which creates e.g.:
<source>
{"success":true,"message":"The request was successful.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can also manually set the error flag to 'false' with the help of the third argument ($error):
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_ERROR'), true);
</source>
which creates e.g.:
<source>
{"success":false,"message":"The was an error.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>
Please note that this way you can also send some data back.

Regardless of having an error response or a success response JResponseJson sends all messages back to the client that have been gathered in the application object:
<source lang="php">
$app = JFactory::getApplication();
// Some code ($result = ...)
$app->enqueueMessage('This part was successful');
// Some more code
$app->enqueueMessage('Here was a small warning');

echo new JResponseJson($result, 'Main response message');
</source>

This results in
<source>
{"success":true,"message":"Main response message","messages":"<<all the encoded messages of $app>>","data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can see the big advantage of that below in the JavaScript section.

If you don't want to send the messages back (rather that they stay in the session), simply set the fourth argument ($ignoreMessages) of the contructor to 'true'.

=== Corresponding JavaScript Code ===

Here is some sample JavaScript used which can be used on the client side together with JResponseJson on the server side.
The example is written with some Mootools code, but something similar can also be done with jQuery or any other JavaScript library for Ajax requests.

<source lang="javascript">
var req = new Request.JSON({
method: 'post',
url: 'index.php?option=com_component&task=mycontroller.execute&format=json',
onSuccess: function(r)
{
if (!r.success && r.message)
{
// Success flag is set to 'false' and main response message given
// So you can alert it or insert it into some HTML element
alert(r.message);
}

if (r.messages)
{
// All the enqueued messages of the $app object can simple be
// rendered by the respective helper function of Joomla!
// They will automatically be displayed at the messages section of the template
Joomla.renderMessages(r.messages);
}

if (r.data)
{
// Here you can access all the data of your response
alert(r.data.myfirstcustomparam);
alert(r.data.mysecondcustomparam);
}
}.bind(this),
onFailure: function(xhr)
{
// Reaching this point means that the Ajax request itself was not successful
// So JResponseJson was never called
alert('Ajax error');
}.bind(this),
onError: function(text, error)
{
// Reaching this point means that the Ajax request was answered by the server, but
// the response was no valid JSON (this happens sometimes if there were PHP errors,
// warnings or notices during the development process of a new Ajax request).
alert(error + "\n\n" + text);
}.bind(this)
});
req.post('anyparam=myvalue');
</source>

== Best Practice ==
As already seen above, code of the controller can be kept very simple using JResponseJson. The model is calculating the data which can be passed to JResponseJson afterwards (of course you can still modify it in the controller if you want to). If you are developing an MVC component you should save such a controller in a file called 'mycontroller.json.php' and place it inside your 'controllers' folder.
This way, that controller is automatically executed if your request URL contains 'format=json'.

Please note that as you can see in the example, there is no need for closing the application (e.g. $app->close();) because the architecture of Joomla! handles that for you. So, this is very clean and good programming.

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

echo new JResponseJson($count);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

===Additional Note===

If you want to support no-js users by for example doing the same task with a normal request and a final redirect back to the page, there is not much you have do additionally. Just create another controller (now with name 'mycontroller.php') and code like this:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
$app = JFactory::getApplication();
$app->setRedirect(JRoute::_('index.php?option=com_mycomponent&view=myview', false));

try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

$app->setMessage(JText::plural('COM_COMPONENT_COUNT_TASK', $count));
}
catch(Exception $e)
{
$app->setMessage(JText::sprintf('COM_COMPONENT_COUNT_TASK_ERROR', $e->getMessage()), 'error');
}
}
}</source>

No changes necessary in the model!

So depending on whether you do the request with 'format=json' (Ajax-Request) or via normal request (without 'format' parameter), the correct controller is executed automatically and the response is prepared accordingly.

[[Category:Extension development]]
[[Category:Component Development]]
[[Category:AJAX]]

JSON Responses with JResponseJson

2013-09-28T20:26:01Z

Chraneco: /* Overview */

{{version/tutor|3.x}}
== Overview ==

Recently a new class JResponseJson was added to Joomla! 3.x which is able to simplify things with Ajax requests. With that class it is now possible to prepare responses to Ajax requests in a standardized and easy manner. You can have a look at the file here:
https://github.com/joomla/joomla-cms/blob/master/libraries/cms/response/json.php
It will mostly be used in controllers of components where you get the following advantages:

* Using the flag 'success' the JavaScript code (whether Mootools JRequest.JSON or jQuery.getJSON) can check whether the task was successful or not and react accordingly (If the request itself failes the error event of the JavaScript API can be used).
* Then, the actual response data (if any) can be retrieved from 'data' in the JSON object and
* optionally a main response message from 'message'.
* Additionally, all gathered messages in the JApplication message queue are also automatically sent back in 'messages'. This can optionally be turned off.

Another advantage is that no $app->close(); is necessary anymore if the Ajax request is done with 'format=json' because the already existing API handles the rest. Just echo the response object at the end of the task.

== How to Use ==
=== Most Common Cases ===

Here is an example controller file:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$result = $this->getModel('example')->createSomething($anyParam);

echo new JResponseJson($result);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

As you can see in the default case the return value of something that has been calculated by the model is simply pushed into a new JResponseJson object and written to the output. This will automatically create a JSON encoded string as follows (except that it is more compressed in reality):

<source>
{"success":true,"message":null,"messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

So, in the 'data' field you can send any array, object or value you want and the 'success' flag is automatically set to 'true'.

If any exception occured in the model this exception is simply passed directly to a new JResponseJson object in our example which would create the following output:

<source>
{"success":false,"message":"This is the message of the exception","messages":null,"data":null}
</source>

Since it is an exception the 'success' flag was automatically set to 'false' and the message of the exception became the main response message.

=== Additional Options ===

If not an exception is passed as the first argument of the JResponseJson constructor you can specify an arbitrary main response message by passing a string as the second argument:
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_SUCCESS'));
</source>
which creates e.g.:
<source>
{"success":true,"message":"The request was successful.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can also manually set the error flag to 'false' with the help of the third argument ($error):
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_ERROR'), true);
</source>
which creates e.g.:
<source>
{"success":false,"message":"The was an error.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>
Please note that this way you can also send some data back.

Regardless of having an error response or a success response JResponseJson sends all messages back to the client that have been gathered in the application object:
<source lang="php">
$app = JFactory::getApplication();
// Some code ($result = ...)
$app->enqueueMessage('This part was successful');
// Some more code
$app->enqueueMessage('Here was a small warning');

echo new JResponseJson($result, 'Main response message');
</source>

This results in
<source>
{"success":true,"message":"Main response message","messages":"<<all the encoded messages of $app>>","data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can see the big advantage of that below in the JavaScript section.

If you don't want to send the messages back (rather that they stay in the session), simply set the fourth argument ($ignoreMessages) of the contructor to 'true'.

=== Corresponding JavaScript Code ===

Here is some sample JavaScript used which can be used on the client side together with JResponseJson on the server side.
The example is written with some Mootools code, but something similar can also be done with jQuery or any other JavaScript library for Ajax requests.

<source lang="javascript">
var req = new Request.JSON({
method: 'post',
url: 'index.php?option=com_component&task=mycontroller.execute&format=json',
onSuccess: function(r)
{
if (!r.success && r.message)
{
// Success flag is set to 'false' and main response message given
// So you can alert it or insert it into some HTML element
alert(r.message);
}

if (r.messages)
{
// All the enqueued messages of the $app object can simple be
// rendered by the respective helper function of Joomla!
// They will automatically be displayed at the messages section of the template
Joomla.renderMessages(r.messages);
}

if (r.data)
{
// Here you can access all the data of your response
alert(r.data.myfirstcustomparam);
alert(r.data.mysecondcustomparam);
}
}.bind(this),
onFailure: function(xhr)
{
// Reaching this point means that the Ajax request itself was not successful
// So JResponseJson was never called
alert('Ajax error');
}.bind(this),
onError: function(text, error)
{
// Reaching this point means that the Ajax request was answered by the server, but
// the response was no valid JSON (this happens sometimes if there were PHP errors,
// warnings or notices during the development process of a new Ajax request).
alert(error + "\n\n" + text);
}.bind(this)
});
req.post('anyparam=myvalue');
</source>

== Best Practice ==
As already seen above, code of the controller can be kept very simple using JResponseJson. The model is calculating the data which can be passed to JResponseJson afterwards (of course you can still modify it in the controller if you want to). If you are developing an MVC component you should save such a controller in a file called 'mycontroller.json.php' and place it inside your 'controllers' folder.
This way, that controller is automatically executed if your request URL contains 'format=json'.

Please note that as you can see in the example, there is no need for closing the application (e.g. $app->close();) because the architecture of Joomla! handles that for you. So, this is very clean and good programming.

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

echo new JResponseJson($count);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

===Additional Note===

If you want to support no-js users by for example doing the same task with a normal request and a final redirect back to the page, there is not much you have do additionally. Just create another controller (now with name 'mycontroller.php') and code like this:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
$app = JFactory::getApplication();
$app->setRedirect(JRoute::_('index.php?option=com_mycomponent&view=myview', false));

try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

$app->setMessage(JText::plural('COM_COMPONENT_COUNT_TASK', $count));
}
catch(Exception $e)
{
$app->setMessage(JText::sprintf('COM_COMPONENT_COUNT_TASK_ERROR', $e->getMessage()), 'error');
}
}
}</source>

No changes necessary in the model!

So depending on whether you do the request with 'format=json' (Ajax-Request) or via normal request (without 'format' parameter), the correct controller is executed automatically and the response is prepared accordingly.

[[Category:Extension development]]
[[Category:Component Development]]
[[Category:AJAX]]

JSON Responses with JResponseJson

2013-09-27T23:39:57Z

Chraneco: /* Additional Note */

{{version/tutor|3.x}}
== Overview ==

Recently a new class JResponseJson was added to Joomla! 3.x which is able to simplify things with Ajax requests. With that class it is now possible to prepare responses to Ajax requests in a standardized and easy manner. You can have a look at the file here:
https://github.com/joomla/joomla-cms/blob/master/libraries/cms/response/json.php
It will mostly be used in controllers of components where you get the following advantages:

* Using the flag 'success' the JavaScript code (whether Mootools JRequest.JSON or jQuery.getJSON) can check whether the task was successful or not and react accordingly (If the request itself failes the error event of the JavaScript API can be used).
* Then, the actual response data (if any) can be retrieved from data in the JSON object and
* optionally a main response message from message.
* Additionally, all gathered messages in the JApplication message queue are also automatically sent back in messages. This can optionally be turned off.

Another advantage is that no $app->close(); is necessary anymore if the Ajax request is done with 'format=json' because the already existing API handles the rest. Just echo the response object at the end of the task.

== How to Use ==
=== Most Common Cases ===

Here is an example controller file:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$result = $this->getModel('example')->createSomething($anyParam);

echo new JResponseJson($result);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

As you can see in the default case the return value of something that has been calculated by the model is simply pushed into a new JResponseJson object and written to the output. This will automatically create a JSON encoded string as follows (except that it is more compressed in reality):

<source>
{"success":true,"message":null,"messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

So, in the 'data' field you can send any array, object or value you want and the 'success' flag is automatically set to 'true'.

If any exception occured in the model this exception is simply passed directly to a new JResponseJson object in our example which would create the following output:

<source>
{"success":false,"message":"This is the message of the exception","messages":null,"data":null}
</source>

Since it is an exception the 'success' flag was automatically set to 'false' and the message of the exception became the main response message.

=== Additional Options ===

If not an exception is passed as the first argument of the JResponseJson constructor you can specify an arbitrary main response message by passing a string as the second argument:
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_SUCCESS'));
</source>
which creates e.g.:
<source>
{"success":true,"message":"The request was successful.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can also manually set the error flag to 'false' with the help of the third argument ($error):
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_ERROR'), true);
</source>
which creates e.g.:
<source>
{"success":false,"message":"The was an error.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>
Please note that this way you can also send some data back.

Regardless of having an error response or a success response JResponseJson sends all messages back to the client that have been gathered in the application object:
<source lang="php">
$app = JFactory::getApplication();
// Some code ($result = ...)
$app->enqueueMessage('This part was successful');
// Some more code
$app->enqueueMessage('Here was a small warning');

echo new JResponseJson($result, 'Main response message');
</source>

This results in
<source>
{"success":true,"message":"Main response message","messages":"<<all the encoded messages of $app>>","data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can see the big advantage of that below in the JavaScript section.

If you don't want to send the messages back (rather that they stay in the session), simply set the fourth argument ($ignoreMessages) of the contructor to 'true'.

=== Corresponding JavaScript Code ===

Here is some sample JavaScript used which can be used on the client side together with JResponseJson on the server side.
The example is written with some Mootools code, but something similar can also be done with jQuery or any other JavaScript library for Ajax requests.

<source lang="javascript">
var req = new Request.JSON({
method: 'post',
url: 'index.php?option=com_component&task=mycontroller.execute&format=json',
onSuccess: function(r)
{
if (!r.success && r.message)
{
// Success flag is set to 'false' and main response message given
// So you can alert it or insert it into some HTML element
alert(r.message);
}

if (r.messages)
{
// All the enqueued messages of the $app object can simple be
// rendered by the respective helper function of Joomla!
// They will automatically be displayed at the messages section of the template
Joomla.renderMessages(r.messages);
}

if (r.data)
{
// Here you can access all the data of your response
alert(r.data.myfirstcustomparam);
alert(r.data.mysecondcustomparam);
}
}.bind(this),
onFailure: function(xhr)
{
// Reaching this point means that the Ajax request itself was not successful
// So JResponseJson was never called
alert('Ajax error');
}.bind(this),
onError: function(text, error)
{
// Reaching this point means that the Ajax request was answered by the server, but
// the response was no valid JSON (this happens sometimes if there were PHP errors,
// warnings or notices during the development process of a new Ajax request).
alert(error + "\n\n" + text);
}.bind(this)
});
req.post('anyparam=myvalue');
</source>

== Best Practice ==
As already seen above, code of the controller can be kept very simple using JResponseJson. The model is calculating the data which can be passed to JResponseJson afterwards (of course you can still modify it in the controller if you want to). If you are developing an MVC component you should save such a controller in a file called 'mycontroller.json.php' and place it inside your 'controllers' folder.
This way, that controller is automatically executed if your request URL contains 'format=json'.

Please note that as you can see in the example, there is no need for closing the application (e.g. $app->close();) because the architecture of Joomla! handles that for you. So, this is very clean and good programming.

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

echo new JResponseJson($count);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

===Additional Note===

If you want to support no-js users by for example doing the same task with a normal request and a final redirect back to the page, there is not much you have do additionally. Just create another controller (now with name 'mycontroller.php') and code like this:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
$app = JFactory::getApplication();
$app->setRedirect(JRoute::_('index.php?option=com_mycomponent&view=myview', false));

try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

$app->setMessage(JText::plural('COM_COMPONENT_COUNT_TASK', $count));
}
catch(Exception $e)
{
$app->setMessage(JText::sprintf('COM_COMPONENT_COUNT_TASK_ERROR', $e->getMessage()), 'error');
}
}
}</source>

No changes necessary in the model!

So depending on whether you do the request with 'format=json' (Ajax-Request) or via normal request (without 'format' parameter), the correct controller is executed automatically and the response is prepared accordingly.

JSON Responses with JResponseJson

2013-09-27T23:39:06Z

Chraneco: /* Additional Note */

{{version/tutor|3.x}}
== Overview ==

Recently a new class JResponseJson was added to Joomla! 3.x which is able to simplify things with Ajax requests. With that class it is now possible to prepare responses to Ajax requests in a standardized and easy manner. You can have a look at the file here:
https://github.com/joomla/joomla-cms/blob/master/libraries/cms/response/json.php
It will mostly be used in controllers of components where you get the following advantages:

* Using the flag 'success' the JavaScript code (whether Mootools JRequest.JSON or jQuery.getJSON) can check whether the task was successful or not and react accordingly (If the request itself failes the error event of the JavaScript API can be used).
* Then, the actual response data (if any) can be retrieved from data in the JSON object and
* optionally a main response message from message.
* Additionally, all gathered messages in the JApplication message queue are also automatically sent back in messages. This can optionally be turned off.

Another advantage is that no $app->close(); is necessary anymore if the Ajax request is done with 'format=json' because the already existing API handles the rest. Just echo the response object at the end of the task.

== How to Use ==
=== Most Common Cases ===

Here is an example controller file:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$result = $this->getModel('example')->createSomething($anyParam);

echo new JResponseJson($result);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

As you can see in the default case the return value of something that has been calculated by the model is simply pushed into a new JResponseJson object and written to the output. This will automatically create a JSON encoded string as follows (except that it is more compressed in reality):

<source>
{"success":true,"message":null,"messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

So, in the 'data' field you can send any array, object or value you want and the 'success' flag is automatically set to 'true'.

If any exception occured in the model this exception is simply passed directly to a new JResponseJson object in our example which would create the following output:

<source>
{"success":false,"message":"This is the message of the exception","messages":null,"data":null}
</source>

Since it is an exception the 'success' flag was automatically set to 'false' and the message of the exception became the main response message.

=== Additional Options ===

If not an exception is passed as the first argument of the JResponseJson constructor you can specify an arbitrary main response message by passing a string as the second argument:
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_SUCCESS'));
</source>
which creates e.g.:
<source>
{"success":true,"message":"The request was successful.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can also manually set the error flag to 'false' with the help of the third argument ($error):
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_ERROR'), true);
</source>
which creates e.g.:
<source>
{"success":false,"message":"The was an error.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>
Please note that this way you can also send some data back.

Regardless of having an error response or a success response JResponseJson sends all messages back to the client that have been gathered in the application object:
<source lang="php">
$app = JFactory::getApplication();
// Some code ($result = ...)
$app->enqueueMessage('This part was successful');
// Some more code
$app->enqueueMessage('Here was a small warning');

echo new JResponseJson($result, 'Main response message');
</source>

This results in
<source>
{"success":true,"message":"Main response message","messages":"<<all the encoded messages of $app>>","data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can see the big advantage of that below in the JavaScript section.

If you don't want to send the messages back (rather that they stay in the session), simply set the fourth argument ($ignoreMessages) of the contructor to 'true'.

=== Corresponding JavaScript Code ===

Here is some sample JavaScript used which can be used on the client side together with JResponseJson on the server side.
The example is written with some Mootools code, but something similar can also be done with jQuery or any other JavaScript library for Ajax requests.

<source lang="javascript">
var req = new Request.JSON({
method: 'post',
url: 'index.php?option=com_component&task=mycontroller.execute&format=json',
onSuccess: function(r)
{
if (!r.success && r.message)
{
// Success flag is set to 'false' and main response message given
// So you can alert it or insert it into some HTML element
alert(r.message);
}

if (r.messages)
{
// All the enqueued messages of the $app object can simple be
// rendered by the respective helper function of Joomla!
// They will automatically be displayed at the messages section of the template
Joomla.renderMessages(r.messages);
}

if (r.data)
{
// Here you can access all the data of your response
alert(r.data.myfirstcustomparam);
alert(r.data.mysecondcustomparam);
}
}.bind(this),
onFailure: function(xhr)
{
// Reaching this point means that the Ajax request itself was not successful
// So JResponseJson was never called
alert('Ajax error');
}.bind(this),
onError: function(text, error)
{
// Reaching this point means that the Ajax request was answered by the server, but
// the response was no valid JSON (this happens sometimes if there were PHP errors,
// warnings or notices during the development process of a new Ajax request).
alert(error + "\n\n" + text);
}.bind(this)
});
req.post('anyparam=myvalue');
</source>

== Best Practice ==
As already seen above, code of the controller can be kept very simple using JResponseJson. The model is calculating the data which can be passed to JResponseJson afterwards (of course you can still modify it in the controller if you want to). If you are developing an MVC component you should save such a controller in a file called 'mycontroller.json.php' and place it inside your 'controllers' folder.
This way, that controller is automatically executed if your request URL contains 'format=json'.

Please note that as you can see in the example, there is no need for closing the application (e.g. $app->close();) because the architecture of Joomla! handles that for you. So, this is very clean and good programming.

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

echo new JResponseJson($count);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

===Additional Note===

If you want to support no-js users by for example doing the same task with a normal request and a final redirect back to the page, there is not much you have do additionally. Just create another controller (now with name 'mycontroller.php') and code like this:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
$app = JFactory::getApplication();
$app->setRedirect(JRoute::_('index.php?option=com_mycomponent&view=myview', false));

try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

$app->setMessage(JText::plural('COM_COMPONENT_COUNT_TASK', $count));
}
catch(Exception $e)
{
$app->setMessage(JText::sprintf('COM_COMPONENT_COUNT_TASK_ERROR', $e->getMessage()), 'error');
}
}
}</source>

No changes necessary in the model!

So depending on whether you do the request with 'format=json' (Ajax-Request) or view normal request (without 'format' parameter) the correct controller is executed automatically and the response prepared accordingly.

JSON Responses with JResponseJson

2013-09-27T23:32:04Z

Chraneco: /* Overview */

{{version/tutor|3.x}}
== Overview ==

Recently a new class JResponseJson was added to Joomla! 3.x which is able to simplify things with Ajax requests. With that class it is now possible to prepare responses to Ajax requests in a standardized and easy manner. You can have a look at the file here:
https://github.com/joomla/joomla-cms/blob/master/libraries/cms/response/json.php
It will mostly be used in controllers of components where you get the following advantages:

* Using the flag 'success' the JavaScript code (whether Mootools JRequest.JSON or jQuery.getJSON) can check whether the task was successful or not and react accordingly (If the request itself failes the error event of the JavaScript API can be used).
* Then, the actual response data (if any) can be retrieved from data in the JSON object and
* optionally a main response message from message.
* Additionally, all gathered messages in the JApplication message queue are also automatically sent back in messages. This can optionally be turned off.

Another advantage is that no $app->close(); is necessary anymore if the Ajax request is done with 'format=json' because the already existing API handles the rest. Just echo the response object at the end of the task.

== How to Use ==
=== Most Common Cases ===

Here is an example controller file:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$result = $this->getModel('example')->createSomething($anyParam);

echo new JResponseJson($result);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

As you can see in the default case the return value of something that has been calculated by the model is simply pushed into a new JResponseJson object and written to the output. This will automatically create a JSON encoded string as follows (except that it is more compressed in reality):

<source>
{"success":true,"message":null,"messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

So, in the 'data' field you can send any array, object or value you want and the 'success' flag is automatically set to 'true'.

If any exception occured in the model this exception is simply passed directly to a new JResponseJson object in our example which would create the following output:

<source>
{"success":false,"message":"This is the message of the exception","messages":null,"data":null}
</source>

Since it is an exception the 'success' flag was automatically set to 'false' and the message of the exception became the main response message.

=== Additional Options ===

If not an exception is passed as the first argument of the JResponseJson constructor you can specify an arbitrary main response message by passing a string as the second argument:
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_SUCCESS'));
</source>
which creates e.g.:
<source>
{"success":true,"message":"The request was successful.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can also manually set the error flag to 'false' with the help of the third argument ($error):
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_ERROR'), true);
</source>
which creates e.g.:
<source>
{"success":false,"message":"The was an error.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>
Please note that this way you can also send some data back.

Regardless of having an error response or a success response JResponseJson sends all messages back to the client that have been gathered in the application object:
<source lang="php">
$app = JFactory::getApplication();
// Some code ($result = ...)
$app->enqueueMessage('This part was successful');
// Some more code
$app->enqueueMessage('Here was a small warning');

echo new JResponseJson($result, 'Main response message');
</source>

This results in
<source>
{"success":true,"message":"Main response message","messages":"<<all the encoded messages of $app>>","data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can see the big advantage of that below in the JavaScript section.

If you don't want to send the messages back (rather that they stay in the session), simply set the fourth argument ($ignoreMessages) of the contructor to 'true'.

=== Corresponding JavaScript Code ===

Here is some sample JavaScript used which can be used on the client side together with JResponseJson on the server side.
The example is written with some Mootools code, but something similar can also be done with jQuery or any other JavaScript library for Ajax requests.

<source lang="javascript">
var req = new Request.JSON({
method: 'post',
url: 'index.php?option=com_component&task=mycontroller.execute&format=json',
onSuccess: function(r)
{
if (!r.success && r.message)
{
// Success flag is set to 'false' and main response message given
// So you can alert it or insert it into some HTML element
alert(r.message);
}

if (r.messages)
{
// All the enqueued messages of the $app object can simple be
// rendered by the respective helper function of Joomla!
// They will automatically be displayed at the messages section of the template
Joomla.renderMessages(r.messages);
}

if (r.data)
{
// Here you can access all the data of your response
alert(r.data.myfirstcustomparam);
alert(r.data.mysecondcustomparam);
}
}.bind(this),
onFailure: function(xhr)
{
// Reaching this point means that the Ajax request itself was not successful
// So JResponseJson was never called
alert('Ajax error');
}.bind(this),
onError: function(text, error)
{
// Reaching this point means that the Ajax request was answered by the server, but
// the response was no valid JSON (this happens sometimes if there were PHP errors,
// warnings or notices during the development process of a new Ajax request).
alert(error + "\n\n" + text);
}.bind(this)
});
req.post('anyparam=myvalue');
</source>

== Best Practice ==
As already seen above, code of the controller can be kept very simple using JResponseJson. The model is calculating the data which can be passed to JResponseJson afterwards (of course you can still modify it in the controller if you want to). If you are developing an MVC component you should save such a controller in a file called 'mycontroller.json.php' and place it inside your 'controllers' folder.
This way, that controller is automatically executed if your request URL contains 'format=json'.

Please note that as you can see in the example, there is no need for closing the application (e.g. $app->close();) because the architecture of Joomla! handles that for you. So, this is very clean and good programming.

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

echo new JResponseJson($count);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

===Additional Note===

If you want to support no-js users by for example doing the same task with a normal request and a final redirect back to the page, there is not much you have do additionally. Just create another controller (now with name 'mycontroller.php') and code like this:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
$app = JFactory::getApplication();
$app->setRedirect(JRoute::_('index.php?option=com_mycomponent&view=myview', false));

try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

$app->setMessage(JText::plural('COM_COMPONENT_COUNT_TASK', $count));
}
catch(Exception $e)
{
$app->setMessage(JText::sprintf('COM_COMPONENT_COUNT_TASK_ERROR', $e->getMessage()));
}
}
}</source>

No changes necessary in the model!

So depending on whether you do the request with 'format=json' (Ajax-Request) or view normal request (without 'format' parameter) the correct controller is executed automatically and the response prepared accordingly.

Portal:Developers/Miscellaneous

2013-09-27T23:30:28Z

Chraneco:

* [[Retrieving request data using JInput]] {{JVer|2.5}} and newer
* [[Retrieving data from GET and POST requests]] {{JVer|1.5}}
* [[How to use the filesystem package]]
* [[Application execution order]]
* [[Accessing the current user object]]
* [[Adding JavaScript and CSS to the page]]
* [[Constants]] used in the Joomla [[Framework]].
* [[How to create a custom button]]
* [[How to create a stand-alone application using the Joomla! Framework]]
* [[How to use user state variables]]
* [[Cache]] and [[Using caching to speed up your code]]
* [[Using the installer API to support package installation]]
* [[How to add tooltips to your Joomla! website]]
* [[Display error messages and notices]].
* [[Sharing layouts across views or extensions with JLayout]] {{JVer|3.1}}
* [[Using JLog]]
* [[JSON Responses with JResponseJson]] {{JVer|3.x}}
<noinclude>[[Category:Landing subpages|{{PAGENAME}}]]</noinclude>

Portal:Component Development/Reading list

2013-09-27T23:28:35Z

Chraneco:

* [[Developing a MVC Component|Developing a Model-View-Controller Component]] {{JVer/multi|2.5,3.x}}
* [[Adding ACL rules to your component]] {{JVer/multi|2.5,3.x}}
* [[Adding sortable columns to a table in a component]] {{JVer/multi|2.5,3.x}}
* [[Component Program Flow]]. {{JVer/multi|2.5,3.x}}
::<small>(UML sequence diagrams showing the control flow for a component.)</small>
* [[Creating a file uploader in your component]] {{JVer/multi|2.5,3.x}}
* [[Creating a toolbar for your component]] {{JVer/multi|2.5,3.x}}
* [[J2.5:Creating Mootools accordion or simple slider/toggler|Creating Mootools accordion or simple slider/toggler]] {{JVer|2.5}}
* [[J2.5:Creating PDF views|Creating PDF views]] {{JVer|2.5}}
* [[File Structure and Naming Conventions]] {{JVer/multi|2.5,3.x}}
* [[How to add breadcrumbs]]{{JVer/multi|2.5,3.x}}
* [[How to add custom filters to components]] {{JVer|2.5}}
* [[How to implement XML-RPC in a component]]
* [[JController and its subclass usage overview]] {{JVer/multi|2.5}}
* [[Portal:Platform|Joomla Platform Portal]] {{JVer|platform}}
* [[J2.5:Managing Component Updates|Managing Component Updates - Part 1]] {{JVer|2.5}}
* [[Manifest files]] {{JVer/multi|2.5,3.x}}
::<small>(For the installation of extensions.)</small>
* [[Sending email from extensions]]{{JVer/multi|2.5,3.x}}
* [[Supporting SEF URLs in your component]]{{JVer/multi|2.5,3.x}}
* [[Using a custom image in the menu bar title]]
* [[Using multiple models in an MVC component]] {{JVer/multi|2.5,3.x}}
* [[Using the JHtmlTabs class in a component]] {{JVer/multi|2.5,3.x}}
* [[Using the JToolBar class in the frontend]] {{JVer/multi|2.5,3.x}}
* [[J3.1:Using Tags in an Extension|Using Tags in an Extension]] {{JVer|3.x}}
* [[Xml-rpc changes in Joomla! 2.5]] {{JVer/multi|2.5,3.x}}
* [[JSON Responses with JResponseJson]] {{JVer|3.x}}
<noinclude>[[Category:Landing subpages|{{PAGENAME}}]]{{NOINDEX}}</noinclude>

JSON Responses with JResponseJson

2013-09-27T23:26:55Z

Chraneco: Initial Article

{{version/tutor|3.x}}
== Overview ==

Recently a new class JResponseJson was added to Joomla! 3.x which is able to simplify things with Ajax requests. With that class it is now possible to prepare responses to Ajax requests in a standardized and easy manner. You can have a look at the file here:

It will mostly be used in controllers of components where you get the following advantages:

* Using the flag 'success' the JavaScript code (whether Mootools JRequest.JSON or jQuery.getJSON) can check whether the task was successful or not and react accordingly (If the request itself failes the error event of the JavaScript API can be used).
* Then, the actual response data (if any) can be retrieved from data in the JSON object and
* optionally a main response message from message.
* Additionally, all gathered messages in the JApplication message queue are also automatically sent back in messages. This can optionally be turned off.

Another advantage is that no $app->close(); is necessary anymore if the Ajax request is done with 'format=json' because the already existing API handles the rest. Just echo the response object at the end of the task.

== How to Use ==
=== Most Common Cases ===

Here is an example controller file:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$result = $this->getModel('example')->createSomething($anyParam);

echo new JResponseJson($result);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

As you can see in the default case the return value of something that has been calculated by the model is simply pushed into a new JResponseJson object and written to the output. This will automatically create a JSON encoded string as follows (except that it is more compressed in reality):

<source>
{"success":true,"message":null,"messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

So, in the 'data' field you can send any array, object or value you want and the 'success' flag is automatically set to 'true'.

If any exception occured in the model this exception is simply passed directly to a new JResponseJson object in our example which would create the following output:

<source>
{"success":false,"message":"This is the message of the exception","messages":null,"data":null}
</source>

Since it is an exception the 'success' flag was automatically set to 'false' and the message of the exception became the main response message.

=== Additional Options ===

If not an exception is passed as the first argument of the JResponseJson constructor you can specify an arbitrary main response message by passing a string as the second argument:
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_SUCCESS'));
</source>
which creates e.g.:
<source>
{"success":true,"message":"The request was successful.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can also manually set the error flag to 'false' with the help of the third argument ($error):
<source lang="php">
echo new JResponseJson($result, JText::_('COM_COMPONENT_MY_TASK_ERROR'), true);
</source>
which creates e.g.:
<source>
{"success":false,"message":"The was an error.","messages":null,"data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>
Please note that this way you can also send some data back.

Regardless of having an error response or a success response JResponseJson sends all messages back to the client that have been gathered in the application object:
<source lang="php">
$app = JFactory::getApplication();
// Some code ($result = ...)
$app->enqueueMessage('This part was successful');
// Some more code
$app->enqueueMessage('Here was a small warning');

echo new JResponseJson($result, 'Main response message');
</source>

This results in
<source>
{"success":true,"message":"Main response message","messages":"<<all the encoded messages of $app>>","data":{"myfirstcustomparam":1,"mysecondcustomparam":42, ...}}
</source>

You can see the big advantage of that below in the JavaScript section.

If you don't want to send the messages back (rather that they stay in the session), simply set the fourth argument ($ignoreMessages) of the contructor to 'true'.

=== Corresponding JavaScript Code ===

Here is some sample JavaScript used which can be used on the client side together with JResponseJson on the server side.
The example is written with some Mootools code, but something similar can also be done with jQuery or any other JavaScript library for Ajax requests.

<source lang="javascript">
var req = new Request.JSON({
method: 'post',
url: 'index.php?option=com_component&task=mycontroller.execute&format=json',
onSuccess: function(r)
{
if (!r.success && r.message)
{
// Success flag is set to 'false' and main response message given
// So you can alert it or insert it into some HTML element
alert(r.message);
}

if (r.messages)
{
// All the enqueued messages of the $app object can simple be
// rendered by the respective helper function of Joomla!
// They will automatically be displayed at the messages section of the template
Joomla.renderMessages(r.messages);
}

if (r.data)
{
// Here you can access all the data of your response
alert(r.data.myfirstcustomparam);
alert(r.data.mysecondcustomparam);
}
}.bind(this),
onFailure: function(xhr)
{
// Reaching this point means that the Ajax request itself was not successful
// So JResponseJson was never called
alert('Ajax error');
}.bind(this),
onError: function(text, error)
{
// Reaching this point means that the Ajax request was answered by the server, but
// the response was no valid JSON (this happens sometimes if there were PHP errors,
// warnings or notices during the development process of a new Ajax request).
alert(error + "\n\n" + text);
}.bind(this)
});
req.post('anyparam=myvalue');
</source>

== Best Practice ==
As already seen above, code of the controller can be kept very simple using JResponseJson. The model is calculating the data which can be passed to JResponseJson afterwards (of course you can still modify it in the controller if you want to). If you are developing an MVC component you should save such a controller in a file called 'mycontroller.json.php' and place it inside your 'controllers' folder.
This way, that controller is automatically executed if your request URL contains 'format=json'.

Please note that as you can see in the example, there is no need for closing the application (e.g. $app->close();) because the architecture of Joomla! handles that for you. So, this is very clean and good programming.

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

echo new JResponseJson($count);
}
catch(Exception $e)
{
echo new JResponseJson($e);
}
}
}</source>

===Additional Note===

If you want to support no-js users by for example doing the same task with a normal request and a final redirect back to the page, there is not much you have do additionally. Just create another controller (now with name 'mycontroller.php') and code like this:

<source lang="php">
class MyController extends JControllerLegacy
{
public function execute()
{
$app = JFactory::getApplication();
$app->setRedirect(JRoute::_('index.php?option=com_mycomponent&view=myview', false));

try
{
$anyParam = JFactory::getApplication()->input->get('anyparam');

$count = $this->getModel('example')->countSomething($anyParam);

$app->setMessage(JText::plural('COM_COMPONENT_COUNT_TASK', $count));
}
catch(Exception $e)
{
$app->setMessage(JText::sprintf('COM_COMPONENT_COUNT_TASK_ERROR', $e->getMessage()));
}
}
}</source>

No changes necessary in the model!

So depending on whether you do the request with 'format=json' (Ajax-Request) or view normal request (without 'format' parameter) the correct controller is executed automatically and the response prepared accordingly.