Struts 2 – Validação utilizando Annotations

As seguinte bibliotecas foram utilizadas:

  • commons-logging-1.1.1.jar
  • freemarker-2.3.8.jar
  • ognl-2.6.11.jar
  • struts2-core-2.0.11.1.jar
  • xwork-2.0.4.jar

Primeiro será configurado o arquivo struts.xml da seguinte forma:


<?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>

<include file="struts-default.xml" />

<package name="default" extends="struts-default">

<action name="Login">
<result name="input">index.jsp</result>
<result name="success">success.jsp</result>
<result name="error">index.jsp</result>
</action>

</package>
</struts>

Agora será criada uma página index.jsp com um formulário para login.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Login</title>
<s:head />
</head>
<body>

<s:form action="Login" method="post" validate="true" >
<s:actionmessage/>
<s:textfield name="username" label="Username" size="14" required="true" />
<s:password name="password" label="Password" size="14" required="true" /><br/>
<s:submit name="login" value="Login" type="button" align="center" method="post" required="true"/>

</s:form>

A tag <s:head /> adiciona um link ao css e javascripts utilizado para redenrizar os elementos do struts na página. Também é colocado o atributo validate=”true” e nos campo username e password é colocado o atributo required=”true”.

Também será criada uma página que será exibida quando o usuário e senha digitados no formulário de login correspoderem a string “admin”.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Success</title>
</head>
<body>
<h1>Success Login! </h1>
</body>
</html>

Agora será criada uma classe para ser a Action e que se chamará LoginAction:


public class LoginAction extends ActionSupport{

private static final long serialVersionUID = -1200187785923962284L;

private String username;
private String password;

public String login(){

if(username == "admin" && password == "admin"){
return "success";
}

return "error";
}

public String post(){
return "success";
}

/**
* @param username the username to set
*/
@RequiredStringValidator(type=ValidatorType.SIMPLE, trim=true, fieldName="username", message="Fill username field")
public void setUsername(String username) {
this.username = username;
}

/**
* @return the username
*/
public String getUsername() {
return username;
}

/**
* @param password the password to set
*/

@RequiredStringValidator(type=ValidatorType.SIMPLE, trim=true, fieldName="password", message="Fill password field")
public void setPassword(String password) {
this.password = password;
}

/**
* @return the password
*/
public String getPassword() {
return password;
}

}

Para a validação, foram colocados nos métodos sets dos atributos a anotação @RequiredStringValidator colocando o tipo de validação, como se trata de textfields será utilizado o o tipo SIMPLE. Colocamos a função trim como true, passamos o nome do campo a ser validado e mensagem que deve aparecer caso a validação falhe.

Página de login antes da submissão dos dados
Formulário de login após submeter formulário com os campos vazios e com espaços em branco.
Página que é mostrada quando os campos de login correspondem a string “admin”
Anúncios

Jython – Java Magazine 95

Para quem se interessa em aprender sobre Jython, Python na plataforma Java, indico ler o artigo do Luis Antonio Tavares publicado na Java Magazine deste mês  (nº95). O artigo aborda conceitos exemplificando-os através de trecho de códigos focando na construção de uma aplicação Swing utlizando Jython.

Spring – DI Utilizando Annotations

Para que se possa habilitar a configuração dos beans por anotações, será utilizado no arquivo de configuração do Spring o elemento <context:annotationconfig/>. A listagem a seguir ilustra o uso deste elemento.


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-
3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-
3.0.xsd">
<context:annotation-config/>
</beans>

A listagem seguinte ilustra a classe Message, que possui alguns atributos prédefinidos no código e seus respectivos métodos de acesso.


@Component
public class Message {
@Value("Somebody")
private String author;
@Value("It's DI with Spring's annotation")
private String message;
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}

A classe MessegerImpl implementa a interface Messeger. A anotação @Service é uma especialização da anotação @Component, ela é usada especificamente para indicar um serviço.


@Service("messeger")
public class MessegerImpl implements Messeger {
@Override
public void writeMessage(Message message) {
System.out.println("Author: " + message.getAuthor());
System.out.println("Message: " + message.getMessage());
}
}

A próxima classe é a WelcomeController, nesta classe de controle existem dois atributos: uma mensagem e um mensageiro. Estes atributos são anotados com o @Autowired, isto fará com que o Spring injete uma instância da classe correspondente no atributo. Pode-se notar então que os atributos não são instanciados, eles são usados diretamente.


@Controller
public class WelcomeController {
@Autowired
private Message message;
@Autowired
private Messeger messeger;
@RequestMapping("/showMessage")
public void showMessage(){
messeger.writeMessage(message);
}
}

Fonte: TAVARES, L. A; TRIPOLI, C. S. – SAS – Sistema de Avaliações e Simulados – Pouso Alegre. UNIVÁS, 2010. 76f.

SAS – Sistema de Avaliações e Simulados

No final do ano passado apresentei o meu TCC – Trabalho de Conclusão de Curso, que consistiu em um projeto chamado SAS – Sistema de Avaliações e Simulados.

Este trabalho tem como objetivo apresentar uma proposta de software para auxiliar nos processos avaliativos. A ferramenta desenvolvida possibilita ao professor a geração de avaliações e simulados, correção e análise de desempenho dos mesmos. Os testes poderão ser realizados online ou poderão ser impressos. Alunos também poderão acessar relatórios de desempenho. A modelagem do sistema foi feita utilizando a metodologia de desenvolvimento ICONIX que é apresentada no decorrer do trabalho. O sistema foi desenvolvido utilizando a linguagem Java, e alguns frameworks como Spring e EclipseLink. Além das tecnologias, são abordados conceitos relacionados à avaliação, ao ENADE e à avaliação institucional.

O trabalho e a apresentação em Power Point pode ser baixada nos links abaixo:

TCC – SAS Sistema de Avaliações e Simulados em PDF

TCC – Apresentação SAS Sistema de Avaliações e Simulados em PDF

Artigo Integrando Spring 3.0 e JPA 2.0 – Java Magazine 83

A revista Java Magazine deste mês (edição 83) trás um artigo que escrevi sobre a integração do framework Spring com JPA.

O artigo trata de como fazer a integração do Spring 3.0 e JPA 2.0. No decorrer do artigo é implementado um exemplo demonstrando o funcionamento das duas tecnologias e como elas podem trazer vantagens para a camada de persistência da sua aplicação, simplificando e desacoplando código, obtendo desta forma, facilidade de manutenção e um código mais limpo.

Abaixo segue a lista de todos os artigos publicados nesta edição:

A versão digital desta edição já está liberada e acredito que em breve a versão impressa já deve estar nas bancas. Espero que gostem do artigo!

eco4planet – O Buscador Ecologicamente Correto!!!

O eco4planet é um buscador que utiliza o sistema Google™ Pesquisas Personalizadas que tráz a qualidade das pesquisas Google agregando consciência ambiental. O buscador utiliza predominantemente a cor preta garando assim uma economia de energia de até 20% comparando com o buscador de tela branca. De acordo com site do eco4planet:

Considerando as mais de 2,55 bilhões de buscas diárias realizadas no Google™ com tempo médio suposto em 10 segundos por pesquisa e a proporção de monitores por tecnologia utilizada, teríamos com um buscador de fundo preto a economia anual de mais de 7 Milhões de Kilowatts-hora! Esse valor equivale à:

  • Mais de 63 milhões de televisores em cores desligados por 1 hora;
  • Mais de 77 milhões de geladeiras desligadas por 1 hora;
  • Mais de 175 milhões de lâmpadas desligadas por 1 hora;
  • Mais de 58 milhões de computadores desligados por 1 hora.

Bom, isso faz muita diferença neh! Além disso a cada 50 mil acessos uma árvore é plantada. Esta é uma forma de mostrar que todos tem a possibilidade de ajudar este planeta de alguma forma. Então se você utiliza o Google como buscador comece também a usar o eco4planet!!!

Considerando as mais de 2,55 bilhões de buscas diárias realizadas no Google™ com tempo médio suposto em 10 segundos por pesquisa e a proporção de monitores por tecnologia utilizada, teríamos com um buscador de fundo preto a economia anual de mais de 7 Milhões de Kilowatts-hora! Esse valor equivale à:

  • Mais de 63 milhões de televisores em cores desligados por 1 hora;
  • Mais de 77 milhões de geladeiras desligadas por 1 hora;
  • Mais de 175 milhões de lâmpadas desligadas por 1 hora;
  • Mais de 58 milhões de computadores desligados por 1 hora.

Prototype

Prototype também é um padrão de projeto (design pattern) criacional, seu objetivo é a criação de objetos a partir de um modelo, um protótipo já estabelecido, ele é usado em casos em que se é necessário a criação de vários objetos de uma classe cujo tais objetos sejam semelhante.

Para isso deve-se criar um objeto modelo (protótipo) clonável e fazer as atribuições que são comuns a todos os objetos ou os valores default. A classe deve implementar a interface Clonable.


public class Aluno implements Cloneable {
private String nome;
private String cidade;
private String cep;
private String universidade;
private Boolean possuiDependencia;
private ArrayList<Float> notas = new ArrayList<Float>();

 // GETTERS AND SETTERS
...
}

No metodo clone poderá ser feito a clonagem do protótipo, no caso da array, terá que ser feito um for, clonando a array manualmente, pois senão ele apenas criará uma referência para o mesmo objeto e então se um elemento for alterado em uma lista será alterado nas outras também.


protected Object clone() throws CloneNotSupportedException {

   Aluno novoAluno = (Aluno) super.clone();
   if(this.notas != null){
     novoAluno.notas = new ArrayList<Float>();
     for(Float f : this.notas){
        novoAluno.notas.add(f);
     }
   }
 return novoAluno;
 }

Usando:


public static void main(String[] args) throws CloneNotSupportedException {

Aluno alunoPrototipo = new Aluno();
alunoPrototipo.setCidade("Cidade Default");
alunoPrototipo.setCep("Cep Default");
alunoPrototipo.setUniversidade("Universidade Defaut");
alunoPrototipo.setDependencias(false);

Aluno a1 = (Aluno) alunoPrototipo.clone();
a1.setNome("José");
System.out.println(a1);

Em UML:

Clonable

Referência: Aula de Engenharia de Software – Profº Marcio – Univás.