Ajax
Ajax é uma tecnologia que permite que partes da tela sejam atualizadas dinamicamente. O NEO possui suporte a esse recurso. A maneira mais simples de se fazer uma chamada ajax é utilizar a função Javascript sendRequest incluida no arquivo ajax.js. 
function sendRequest(url,params,HttpMethod, callbackfunction, errorcallback)
Essa função recebe os seguintes parâmetros:
Exemplo de utilização dessa função (suponha o seguinte controller e JSP): 
package exemplo;

import java.io.IOException;

import org.springframework.web.servlet.ModelAndView;

import br.com.linkcom.neo.controller.Controller;
import br.com.linkcom.neo.controller.DefaultAction;
import br.com.linkcom.neo.controller.MultiActionController;
import br.com.linkcom.neo.core.web.WebRequestContext;

@Controller(path="/modulo/Ajax")
public class AjaxController extends MultiActionController{

	public void funcaoAjax(WebRequestContext request) throws IOException{
		request.getServletResponse().getWriter().println( "Mensagem do servidor" );
	}
}

[JSP]
<%@ taglib prefix="n" uri="neo"%>
<html>
	<head>
		<n:head/>
	</head>
	<body>
		<script type="text/javascript">
			function executarAjax(){
				sendRequest('/app/modulo/Ajax','ACAO=funcaoAjax','POST', ajaxCallback, erroCallback);
			}
			
			function ajaxCallback(data){
				alert(data);
			}
			
			function erroCallback(request){
				alert('Erro no ajax!\n' + request.responseText);
			}
		</script>

		<button onclick="executarAjax()">Testar ajax</button>
	</body>
</html>
Foi criado um botão com um evento javascript que executa o método executarAjax. A função executarAjax chama a função sendRequest passando como parâmetro a url (incluindo o nome da aplicação) do controller desejado, o parâmetro ACAO indicando que a action que deve ser executada no controller é a funcaoAjax, o método Http POST, a função de callback para quando a requisição for concluída e a função caso ocorra algum erro. A função ajaxCallback recebe um parâmetro data. Esse parametro é o conteúdo do texto que o servidor enviou. No caso, ao se fazer uma chamada ajax o controller irá imprimir na saída 'Mensagem do servidor' que chegará na função ajaxCallback através do parâmetro data. A função ajaxCallback faz um alert dessa variável mostrando o que foi enviado pelo servidor.

Dica: Uma action de um controller pode tanto retornar um ModelAndView quanto não retornar nada. Quando desejar imprimir na saída padrão, como foi o caso, é útil utilizar o tipo de retorno void.
Combo Reload Group
O NEO também possui uma tag para facilitar a utilização de ajax em combos dependentes. Essa tag é a comboReloadGroup. Essa tag agrupa determinados combos e cria o javascript para carregar os itens de um determinado combo de acordo com o valor de outro combo.
Vamos ver um exemplo. Suponha que temos as classes País, Estado e Cidade. A classe Cidade tem uma referência para Estado e a classe Estado tem uma referência para País. Agora suponhamos um outro bean com um campo que faz referência à Cidade.
Para criar um combo de cidade na tela, poderiamos utilizar a tag t:property como no exemplo: 
[JSP]
	<t:property name="cidade"/>
Lembando que um property para uma classe que é uma entidade, é automaticamente um combo. O código acima monta um combo com todas as cidades encontradas no banco.
Importante: Sempre que precisar utilizar combos no JSP é necessário criar um Servide e um DAO para o bean em questão. O NEO só preenche as informações corretamente se existir um DAO para a entidade.
Para criar a dependencia entre as propriedades. Podemos aproveitar a propriedade estado de cidade, e a propriedade pais de estado. Exemplo: 
[JSP]
	<t:property name="cidade.estado.pais"/>
	<t:property name="cidade.estado"/>
	<t:property name="cidade"/>
Agora temos 3 combos. Cada um com todos os resultados obtidos do banco de dados. Uma outra forma de ter os três combos seria ter uma propriedade estado e pais no mesmo bean que possui a propriedade cidade. Se o bean que possui a propriedade cidade for uma entidade (configurado com @Entity) e ele não possuir chaves para estado e país deve ser colocada a anotação @Transient no getter de cada propriedade. Tendo as 3 propriedade no mesmo bean o jsp ficaria dessa forma: 
[JSP]
	<t:property name="pais"/>
	<t:property name="estado"/>
	<t:property name="cidade"/>
Importante: A anotação @Transient indica para o hibernate que o campo não é persistido no banco de dados. Verifique a documentação do Hibernate Annotations para mais informações.
Para indicar que os 3 combos são dependentes precisamos englobá-los na tag comboReloadGroup. 
[JSP]
	<n:comboReloadGroup>
		<t:property name="cidade.estado.pais"/>
		<t:property name="cidade.estado"/>
		<t:property name="cidade"/>
	</n:comboReloadGroup>
A tag comboReloadGroup vai efetuar um reload da tela para atualizar os combos. Se desejar que essa funcionalidade seja feita via ajax é só utilizar a propriedade useAjax. 
[JSP]
	<n:comboReloadGroup useAjax="true">
		<t:property name="cidade.estado.pais"/>
		<t:property name="cidade.estado"/>
		<t:property name="cidade"/>
	</n:comboReloadGroup>
Quando utilizar a tag comboReloadGroup o método no DAO que será utilizado para fazer as pesquisas será o findBy, mas é possível especificar outro método para as queries. Suponha que criamos o método findCidadesHabilitadasByEstado que efetua uma determinada query e que recebe um parâmetro estado.
Para utilizar esse método no reload fazemos o seguinte: 
[JSP]
	<n:comboReloadGroup useAjax="true">
		<t:property name="cidade.estado.pais"/>
		<t:property name="cidade.estado"/>
		<t:property name="cidade" itens="cidadeDAO.findCidadesHabilitadasByEstado(cidade.estado)"/>
	</n:comboReloadGroup>
Os parâmetros da função da propriedade itens devem ser o nome de uma propriedade colocada na tela. Se determinado bean possuir a propriedade X mas esse X não for colocado na tela, não será possível utilizar uma função fazendo referência a X.

É possível passar mais de um parâmetro para a função em itens.