Java Game : PulpCore : framework de animação 2D

PulpCore - para quem está interessado na área de desenvolvimento de games em java, vai a dica, este framework é bem interessante e serve como uma engine, para animações em 2D, vi um game desenvolvido com este framework, mais especificamente uma applet e pela qualidade e resultado final, não deixou em nada a desejar para um game desenvolvido em Flash, tempo de load, ao meu ver muito rápido.

veja também:
- Pulp Games
- Interactive Pulp
- PulpCore

Java : Novidade : Spring-On-Rails 1.0

Spring-On-Rails é um framework para desenvolvimento rápido de aplicações JEE, distintamente do conhecido do Ruby-on-Rails. Este projeto foi projetado para ajudar aos desenvolvedores a gerar esqueletos básicos do tipo CRUD para as aplicações. A aplicação gerada é baseada no framework Spring, Ibatis e Hibernate para a camada intermediária.

O processo básico de desenvolvimento do Spring-on-Rails é muito simples, definir um mapeamento objeto/relacional, então executar um "ant task" para gerar a estrutura do projeto.

O que é gerado é uma aplicação simples de atualização, leitura e remoção.

Este projeto está licenciado sobre a ASL 2.0 ( Apache Software License ).

Fonte : TheServerSide.com

Java : Vídeo/Slideshow Spring 2.0

Spring 2.0 agora possibilita um desenvolvimento baseado em classes POJO, com isto possibilitando um novo nível de sofisticação no uso do Spring 2.0. Os temas do Spring 2.0 são simples e poderosos: isto torna possível a realização de tarefas de modo mais fácil, possibilitando o fácil uso da expansibilidade do Spring em novas áreas. No vídeo Rod Johnson explica um número relevante de novidades e características do Spring 2.0, assim como toda a evolução e os planos para o Spring em 2007.

Assista o Vídeo/Slideshow : [link] (em inglês), material disponibilizado no InfoQ.com

comentário: ao que parece esta nova versão está definitivamente muito diferente das anteriores e pelo que é apresentado agora sim está bem otimizado e produtivo, mas ainda não testei nem fiz nenhum projeto utilizando o Spring 2.0, para comprovar se realmente está produtivo como é falado no vídeo...

Fonte : DZone

Hibernate Search 3.0

Hibernate Search 3.0 provê uma poderosa e completa engine de busca para textos persistidos, integravel transparentemente com o Hibernate.

Algumas caraterísticas:
* Indexação sincronizada transparentemente. Isto elimina a necessidade de atualizações manuais dos índices. Essa atualização é gerada pelo núcleo do Hibernate, o que se responsabiliza por essas atualizações.
* Integração simples e fácil com o Hibernate e com as semanticas e APIs de persistência Java. Como resultado, requer mudanças minimas na aplicação quanto ao uso do HQL do Hibernate.
* O produto pode ser extendido, aumentado, costumizado a partir do suporte inicial.

Fonte : TheServerSide.com

Mentawai 1.11

notícia não muito nova, mas para constar, dia 11 de Setembro foi liberado a nova versão do Mentawai veja as mudanças

Frameworks MVC

frameworks que uso/usei em algum projeto/teste:

1 - JSF, implementação da SUN e da Apache( MyFaces )
2 - SpringMVC
3 - Struts 1
4 - Webwork
5 - Struts 2
6 - Mentawai
7 - VRaptor

---

1 - sinceramente não gostei do JSF e ainda não gosto dele, a menos quando utilizei com alguma ferramenta RAD para o JSF em si que me cuidou da parte de configurações ( as configurações necessárias para usar o JSF é o que não me agrada, muito tempo perdido ) [ ainda o considero utópico, se fosse metade do que prega, seria o melhor... ]

2 - outro framework que não gostei nenhum pouco... parece um Struts 1 um pouco mais evoluido, porém chato e pouco produtivo( deixando claro que essa é minha opinião sobre o Spring modulo MVC )

3 - Struts 1, outro framework que você passa mais tempo perdendo tempo com configurações do que programando a camada de negócio da tua aplicação, qualquer manutenção, ou expansão da aplicação é torturante, a estrutura das classes actiom, mapeamento e a obrigatoriedade do FormBean, consomem muito tempo tonando pouco produtivo ao meu ver

4 - Webwork, um framework que esse sim gostei de utilizar e o considerei muito produtivo comparado com os anteriores e sem a dor de cabeça dos formbean do struts 1, framework muito inteligente

5 - Struts 2, usei/uso atualmente, framework um dos que mais gosto, a parte do nucleo dele é o Webwork, muito produtivo, muito facil de usar, configuração minima ou 0, como queira ( você tem opção de escolher ), implementa todas as vantagens do webwork e mais novidades interessantes =]

6 - Mentawai, framework que é um dos outros que gosto muito, muito produtivo, configuração via codigo java, com isso programando no Eclipse da vida você configura como programa java, digita parte incial do que quer, Ctrl + espaço ( auto complete ), rápido, agil, com ótimas características e funcionalidades prontas para uso em conjunto do framework [ Framework Brasileiro ]

7 - VRaptor, esse framework achei muito bom até eu começar a me encrencar com a caracteristica dele ser baseado em CoC ( configuração sobre configuração ) isso é algo bom se tu for fazer nos moldes que ele te proporciona, mas caso queira você mesmo fazer e controlar a saida das action como queira, ae volte aos arquivos de configuração ( o estilo de configurar não me agradou muito ) [ Framework Brasileiro ]

NEO Framework MVC

Liberado o código fonte do framework NEO. O NEO é um framework MVC
desenvolvido pela equipe de desenvolvimento da Linkcom e coordenado por
Rógel Garcia. Ele é baseado no Spring e Hibernate e visa o
desenvolvimento rápido de aplicações web. É um framework inovador,
possui vários recursos como Ajax facilitado, não necessita XML,
utilização de Annotations e Generics. É possível construir um CRUD em
apenas 10 minutos.

Url do projeto: www.neoframework.org

Screencast de demonstração de desenvolvimento de um crud simples:

http://www.neoframework.org/siteneo/tutorial/ver/21/CRUD

Struts 2: Annotation Action : correção

no post anterior fiz algumas considerações baseados nos primeiros testes que realizei utilizando actions + annotations, porém hoje realizando um novo código verifiquei que é possível utilizar outros métodos alem do execute, padrão de uma classe action e também funcionou para uma POJO Action...

ps.: faltava altera uma configuração no struts.xml para habilitar os outros métodos internos dentro da classe action...

segue os novos códigos do teste agora funcionando:

/WEB-INF/[web.xml] configuração da aplicação
tendo os jar´s básicos do struts 2 e o plugin: struts2-codebehind-plugin-2.x.jar

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_S2AA" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>struts2_action_annotations</display-name>  
  <!-- ======= -->   
    <filter>
        <filter-name>struts</filter-name>
        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    <init-param>
      <!-- define os pacotes que irá considerar contendo classes actions -->
      <param-name>actionPackages</param-name>
      <!--  para definir mais de um pacote utilize "," -->
      <param-value>actions</param-value>
    </init-param>
    </filter>
  <!-- ======= -->
    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  <!-- ======= -->    
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

Obs.: usando esse tipo de definição de mapeamento de action não é necessário definir nenhum mapeamento no struts.xml para as actions do pacote indicado, porém é necessário habilitar a chamada dinâmica de outros métodos internos da action( aconselho a sempre utilizar como true essa configuração )

/WEB-INF/classes/[struts.xml]
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

  <!-- habilita o uso de outros métodos de action internamente na classe action -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    <constant name="struts.devMode" value="false" />

  <!-- configuração automática -->
  
</struts>

classe action
package actions;

import org.apache.struts2.config.Result;
import org.apache.struts2.config.Results;

@Results({
    @Result(name="success", value="/jsp/result.jsp"),
    @Result(name="method_1", value="/jsp/result.jsp"),
    @Result(name="method_2", value="/jsp/result.jsp")
})
public class AnnotAction  {
  //--------------------------------------------------------------------------
  private static final long serialVersionUID = 1L;
  //--------------------------------------------------------------------------
  private String message;
  //--------------------------------------------------------------------------  
  public String execute() {
    this.setMessage( "Success" );
    return "success";
  }
  
  public String method_1() {
    this.setMessage( "Method 1" );
    return "method_1";
  }
  
  public String method_2() {
    this.setMessage( "Method 2" );
    return "method_2";
  }
  //--------------------------------------------------------------------------
  public String getMessage() {
    return message;
  }

  public void setMessage(String message) {
    this.message = message;
  }
  //--------------------------------------------------------------------------
}

/jsp/[result.jsp]
<%@ taglib prefix="s" uri="/struts-tags" %>
<center><s:property value="message"/></center>

no jsp exibe apenas a mensagem =]

agora sim funcionando corretamente...

Struts 2: Annotation Action

uma característica interessante do Struts 2 é o suporte a anotações, nesse caso vou falar sobre o suporte para definição de action...


.:verifique o post de correção desse [link]:.

segue os respectivos códigos

/WEB-INF/[web.xml] configuração da aplicação
tendo os jar´s básicos do struts 2 e o plugin: struts2-codebehind-plugin-2.x.jar

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_S2AA" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>struts2_action_annotations</display-name>  
  <!-- ======= -->   
    <filter>
        <filter-name>struts</filter-name>
        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    <init-param>
      <!-- define os pacotes que irá considerar contendo classes actions -->
      <param-name>actionPackages</param-name>
      <!--  para definir mais de um pacote utilize "," -->
      <param-value>actions</param-value>
    </init-param>
    </filter>
  <!-- ======= -->
    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  <!-- ======= -->    
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

Obs.: usando esse tipo de definição de mapeamento de action não é necessário definir nenhum mapeamento no struts.xml para as actions do pacote indicado


actions.[AnnotationAction] : classe action

package actions;

import org.apache.struts2.config.Result;
import com.opensymphony.xwork2.ActionSupport;

@Result(name="success", value="/jsp/success.jsp")
public class AnnotAction extends ActionSupport {
  private static final long serialVersionUID = 1L;
  public String execute() {
    return "success";
  }  
}

ps.: a página JSP de resultado da action contém nesse exemplo um texto qualquer, apenas para verificar o funcionamento da action...


considerações:

quanto a esse tipo de mapeamento verifiquei que funcionou apenas para o método execute da classe action, sendo que esta herdava de ActionSupport para ser reconhecida como uma action dentro desse pacote....

tentei acessar outros metodos internos na mesma action, mapeada dessa forma, verifiquei que o Struts 2 não localizava tais métodos...


de modo geral esse tipo de action é bom para casos de actions onde conterá apenas um método executor, no caso padrão o public String execute()...

minhas opinião final: achei esse suporte muito fraco, foi menos que minha espectativa inicial :(

Struts 2 + Tiles 2

outra funcionalidade muito utilizada em aplicações web que reduzem o tempo de desenvolvimento referente a interface é o esquema de templates e layout de interface, no caso com Struts 2 temos 2 possibilidades/soluções que podemos utilizar para essa finalidade:

- SiteMesh
- Tiles

no caso como anteriormente tive boas experiências no uso do Tiles junto com o Struts 1, resolvi verificar como está o uso entre Struts 2 com a nova versão do Tiles 2...

um pequeno problema...
opa calma, deixa eu explica, o problema que tive inicialmente foi encontrar uma fonte que realmente contivesse a informação de como realizar a integração entre ambos, a qual fui achar somente em um forum da França, no respectivo [link]

bom vamos aos códigos agora...

[web.xml] configurando a aplicação para utilizar Struts 2 com Tiles 2
( necessário dos jar´s do Struts 2 e do Tiles 2 [usei o 2.0.3, core e api] na lib da aplicação )

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_Struts_Tiles" version="2.4" 
  xmlns="http://java.sun.com/xml/ns/j2ee" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <display-name>Struts 2 Tiles 2 - Example</display-name>
  <!-- ======= -->   
    <filter>
        <filter-name>struts</filter-name>
        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    </filter>
  <!-- ======= -->
    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  <!-- ======= -->    
  <listener>
      <listener-class>org.apache.tiles.listener.TilesListener</listener-class>
    </listener>  
  <!-- ======= -->    
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.jsp</welcome-file>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>

</web-app>

WEB-INF/[tiles.xml] configuração referente ao layout/templates

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
        "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
        "http://struts.apache.org/dtds/tiles-config_2_0.dtd">     
<tiles-definitions>
   <!-- definição do layout da página principal -->
   <definition name="template.page" template="/template/layout.jsp">
      <put name="title" value="Struts 2 + Tiles 2"/>
      <put name="header" value="/template/headerMain.jsp"/>
      <put name="menu" value="/template/menuMain.jsp"/>        
      <put name="footer" value="/template/footerMain.jsp" />
   </definition>
   <definition name="welcome.page" extends="template.page">
      <put name="body" value="/jsp/welcome.jsp"/>
   </definition>
</tiles-definitions>

ps.: nessa aplicação defini os respectivos diretório no root da aplicação:
- jsp : para os jsp´s de resultado das action
- template : para os layout de tela a ser setados no Tiles


/template/[layout.jsp] layout da tela

<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<%-- atributo da request --%>
<tiles:importAttribute name="title" scope="request"/>
<%-- definição do layout --%>
<html>
  <head>
    <!-- recupera o atributo setado na definição do tiles.xml -->
    <title><tiles:getAsString name="title"/></title>
  </head>
  <body>  
    <table width="100%" height="100%">
      <tr bgcolor="yellow">
        <td colspan="2">
          <tiles:insertAttribute name="header" />
        </td>
      </tr>
      <tr>
        <td bgcolor="gray">
          <tiles:insertAttribute name="menu" />
        </td>
        <td>
          <tiles:insertAttribute name="body" />
        </td>
      </tr>
      <tr bgcolor="yellow">
        <td colspan="2">
          <tiles:insertAttribute name="footer" />
        </td>
      </tr>
    </table>  
  </body>
</html>

ps.: os outros .jsp dentro do diretório possui nesse exemplo apenas textos, indicando : [ cabeçalho, meno e rodapé ]


usando como tipo de retorno de uma action, a definição da action deverá conter o seguinte formato:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>

   <package name="base" extends="struts-default">
      <result-types>
         <result-type name="tiles" class="org.apache.struts2.views.tiles.TilesResult" />
      </result-types>
        
      <action name="index">
         <result type="tiles">welcome.page</result>
      </action>
   </package>  

</struts>



e com essas dicas já é possível iniciar o uso do Struts 2 integrado com Tiles 2 =]

Struts 2: Saída de stream com parametros dinâmicos

usando o novo framework Struts 2, depois de um tempo brigando com a falta de conhecimento finalmente consegui montar uma action onde seto dinâmicamente os parametros para a definição do result

observe os respectivos códigos:

java: classe action
import java.io.ByteArrayInputStream;
import java.io.InputStream;

public class DynamicStreamAction {
  //--------------------------------------------------------------------------
  // parametros para uso na saída da action
  private String contentType;
  private int contentLength;
  private String contentDisposition;
  // definição da saída do stream
  private InputStream myStream;
  //--------------------------------------------------------------------------
  public String execute() {
    
    // definindo o tipo de conteúdo
    this.setContentType( "application/xml" );
    // definindo que será em anexo( solicitará o salvamento do arquivo )
    this.setContentDisposition( "attachment; filename=XmlAction.xml" );
    
    
    // definindo o XML de saida
    String xml = "<tag>xml teste de saída áéíóú ç à...</tag>";
        
    // setando o stream para o tributo
    this.setMyStream( new ByteArrayInputStream( xml.getBytes() ) );

    // definindo o tamanho do contentLength
    this.setContentLength( xml.getBytes().length );    
    return "success";
  }
  //--------------------------------------------------------------------------  
  
  // get´s & set´s

}

respectivo mapeamento da action com definição dos parametros do result, tipo stream dinâmicos
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

    <package name="stream" namespace="/stream" extends="struts-default">

        <action name="dynamic" class="stream.DynamicStreamAction">
      <result name="success" type="stream">
        <param name="inputName">myStream</param>  
        <param name="contentType">${contentType}</param>  
        <param name="contentDisposition">${contentDisposition}</param>
        <param name="contentLength">${contentLength}</param>
      </result>
        </action>

    </package>
</struts>

* Observe: que os parametros definidos no mapeamento da action são respectivamente os mesmo nomes dos atributos da classe action...

Model Driven

nos ultimos tempos, nos atuais frameworks web MVC java tenho visto falar muito sobre Model Driven, mas na prática compreender como que isso se encaixa em um framework MVC fica meio obscuro...

em si a minha compreensão vendo essa característica em uma aplicação web, foi a possibilidade de facilitar o desenvolvimento e trabalhar uma interface baseada em modelos...

* observando na aplicação showcase do Struts 2, por exemplo, facilita o entendimento da aplicação prática de Model Driven.
essa aplicação está disponível junto do struts-2.0.6-all.zip no diretório apps

links para leitura sobre o assunto:
- OMG - Model Driven Architecture
- IMB - An introduction to Model Driven Architecture
- Dataware - MDA (Model Driven Architecture)
- MundoOO - Java e Model Driven Architecture (MDA)
- Portal Java - MDA - Model Driven Architeture
- JavaPro - Java and the Model Driven Architecture

Java : Framework MVC : Mentawai

algumas pessoas andaram me perguntando sobre o que vem a ser esse tal Mentawai, é bom?

minhas considerações sobre ele:
- agradável de programar
- filosofia "No XML": chega de ficar usando um monte de xml's para configurar framework
- como consequência do item anterior ganho na produtividade
- quanto a performance e execução não deixa nada a desejar para os outros frameworks existentes no mercado atualmente, como: Struts, Webwork, MyFaces, Spring; digo até que é muito mais facil de usar...

Atualmente: na versão 1.8 com um conjunto muito bom para apoio e desenvolvimento, outro fato referente a ele que me chamou a atenção foi a facilidade para desenvolver um suporte para otimizar ainda mais a produtividade com esse framework.

Mas quem usa ele ou já testou?
quem já usou/usa e quais foram suas respectivas considerações sobre o Mentawai

um caso de uso: Tribunal de Contas do Estado do Ceará
informações e notícias sobre esse assunto:
- forum Mentawai
- Slackware-Brasil
- Notícias Linux

alguns links que falam do Mentawai: [JavaFree:wiki][TheServerSide][JavaWorld]