Actions codificadas em linguagens dinâmicas

Olá,

O que vocês acham de actions codificadas em linguagens dinâmicas?
Estou pensando em usar isso. Como as actions fazem parte do controller, o que eles devem fazer de verdade e chamar a camada de negócio, passando os dados da camade de visão devidamente validados e formatados (desde que essa validação e formatação não tenha uma lógica de negócios muito “pesada”).
Geralmente não fazem muito processamento, ou seja, não vamos ter muitos problemas com performace. E com Groovy por exemplo, é possível compilar e aumentar um pouco a performace.

Eu acho que isso traz um ganho de produtividade considerável…

Alguém já teve alguma experiência com isso? O que achou?

To fazendo isso num projeto onde estamos utilizando Spring 2 + Groovy. Como o Spring 2 tem suporte direto pra carga de objetos em outras linguagens dinâmicamente (incluindo aí quando você altera o fonte e ele percebe na hora e recarrega o objeto), as coisas tem indo muito bem.

A idéia mesmo era fazer com que quase todo o desenvolvimento fosse feito com Groovy, mas como ainda tem gente que não está acostumada, não dá pra obrigar né :stuck_out_tongue:

Mas action agora, só escrito e carregado dinâmicamente :smiley:

E o suporte a refactoring, como fica?

Explique-se…

Ok, vamos supor que vc escreve as views usando freemarker e as actions em javascript, jython ou jruby.

Ou seja, o minimo de codigo java que acaba sobrando no seu projeto eh o modelo de dominio e uns pedacos de hibernate aqui e ali.

Dai vc percebe que, na verdade, Account eh uma instancia de Product, e instancias de Product sao ProductHoldings, e esses objetos tem semanticas completamente diferentes do que vc estava esperando.

Voce usa Eclipse ou IntelliJ.

O que vc faz? Senta no canto e chora, ne? :wink:

Ah, bem, aí você esta falando do problema de linguagens com tipagem fraca.

Eu particularmente prefiro usar uma linguagem dinâmica (no sentido de ser totalmente interpretada) mas com tipagem forte.

Bem, o que pode ser feito para contornar o problema para quem usar tipagem fraca?

Eu tinha pessando nisso, quando soube que o Java 6 iria suportar linguagens de script de forma dinâmica. Então pensei, então poderiam construir frameworks como RoR de forma que dentro do Java tive-se uma aplicação rails quase que idêntica a uma RoR.

A diferenca eh que, numa app escrita em Rails, quase todo o “codigo” eh Ruby - e tem um nadica de YAML.

Numa aplicacao J2EE, voce pode usar umas 4 ou 5 “linguagens” diferentes antes de perceber:

  • JSP / Velocity / FreeMarker
  • Properties
  • Hibernate XML
  • web.xml
  • Java

Jogando Jython, Rhino ou JRuby em cima, vc dificulta ainda mais qualquer refactoring, pq nao so as suas ferramentas tem que conhecer todas essas linguagens, mas vc tb tem que ser capaz de saber onde as referencias a objetos de outros mundos tao vindo, e se eles vao ou nao ser afetados.

[quote=cv]A diferenca eh que, numa app escrita em Rails, quase todo o “codigo” eh Ruby - e tem um nadica de YAML.

Numa aplicacao J2EE, voce pode usar umas 4 ou 5 “linguagens” diferentes antes de perceber:

  • JSP / Velocity / FreeMarker
  • Properties
  • Hibernate XML
  • web.xml
  • Java

Jogando Jython, Rhino ou JRuby em cima, vc dificulta ainda mais qualquer refactoring, pq nao so as suas ferramentas tem que conhecer todas essas linguagens, mas vc tb tem que ser capaz de saber onde as referencias a objetos de outros mundos tao vindo, e se eles vao ou nao ser afetados.[/quote]

Puxa, tens toda razão cv. Mas, e se fosse usada apenas uma linguagem, como Groovy? Acho que não seria tão afetado, desde que a equipe toda estivesse por dentro.

Ah, só pra destacar: dá pra contornar o Hibernate XML usando Hibernate Annotations. :slight_smile:

Se você mantêm actions muito simples uma linguagem mais leve pode facilitar, desde que:

1 - Ela elimine algumas das chatices de trabalhar com Servlets/HTTP/Request-Response, se não use Java
2 - Você não tenha um acoplamento tão forte com seus objetos de domínio. Meia dúzia de gets, iterações, poucos condicionais e só.

Deixa eu dar os meus $0,02… no caso do struts, abusar do jakarta commons ajuda um pouco. Vcs conhecem o LazyValidatorForm? Segue um exemplinho:

O JSP:

<html:form action="/abrirAtendimento.do">
	Placa: <html:text property="placa"/> <html:submit property="action" value="Buscar"/> 
	Proprietário: <html:errors property="placa"/> <bean:write name="lazyForm" property="cliente" ignore="true"/>
	&lt;strong&gt;&lt;bean:write name="lazyForm" property="fabricante" ignore="true"/&gt;, &lt;bean:write name="lazyForm" property="modelo" ignore="true"/&gt;, &lt;bean:write name="lazyForm" property="ano" ignore="true"/&gt;&lt;/strong&gt;<br>
	&lt;tr&gt;&lt;td&gt;Combustível: &lt;bean:write name="lazyForm" property="combustivel" ignore="true"/&gt;<br>
	&lt;tr&gt;&lt;td&gt;Cor: &lt;bean:write name="lazyForm" property="cor" ignore="true"/&gt;<br>
&lt;/html:form&gt;

A action:

	public ActionForward execute(ActionMapping actionMapping, ActionForm reqForm, HttpServletRequest request, HttpServletResponse response) throws Exception {
		LazyValidatorForm form = (LazyValidatorForm) reqForm;
		String action = ConvertUtils.convert(form.get("action"));
		if (action.equals("Buscar")) {
			String placa = ConvertUtils.convert(form.get("placa"));
			Veiculo veiculo = facade.procurarVeiculo(placa);
			if (veiculo != null) {
				BeanUtils.copyProperties(form, veiculo);
			} else {
				ActionMessages messages = new ActionMessages();
				messages.add("placa", new ActionMessage("veiculoNaoEncontrado"));
				super.addErrors(request, messages);
			}
		}
		
		return  actionMapping.findForward("SUCCESS");
	}

O struts-config.xml:

&lt;struts-config&gt;
&lt;form-beans&gt;
       &lt;form-bean name="lazyForm"
                type="org.apache.struts.validator.LazyValidatorForm"/&gt;
&lt;/form-beans&gt;
&lt;action-mappings&gt;
&lt;action path="/abrirAtendimento" 
        type="hotmotors.view.AbrirAtendimentoAction"
        name="lazyForm" validate="false"&gt;
        &lt;forward name="SUCCESS"
                path="/WEB-INF/jsp/abrirAtendimento.jsp"
	redirect="false"/&gt;
         &lt;forward name="FAIL"
	path="/WEB-INF/jsp/erro.jsp"
	redirect="false"/&gt;
&lt;/action&gt;
&lt;/action-mappings&gt;
...

Moral da história. Com o LazyForm tudo que está no JSP vai para a Action. Com o copyProperties tudo que está no entity é copiado para o Form. O Lazy form dá uma tipagem mais leve para o form do struts.

Bom… eu ja fiz um framework academico de MVC onde um dos hotspots eram valicações em scripts (groovy ou beanshell) como um aspecto (antes de chegar no action mesmo)

mas o action em si mesmo em script eu já nao sei o que ele tras de tão vantajoso, e até pode atrapalhar no refactoring como ja disseram

PessoALL, eu estou precisando estudar uma dessas linguagens que trabalham com JAVA.
EX: JSP, Velocity, Groovy.

Estou no Rio de Janeiro e estou procurando cursos para trabalhar com isso.