A Especificação JavaBeans define um modelo de componente de software e foi criada para auxiliar desenvolvedores a criar componentes Java que possam ser utilizados de forma fácil por outros desenvolvedores em uma IDE.
A Oracle define que um Java Bean é um componente de software reutilizável que pode ser manipulado visualmente em uma ferramente de desenvolvimento.
Um JavaBean, chamado muitas vezes de apenas Bean, é definido por algumas convenções e regras relativas a nomenclatura, construção e comportamento. Ele deve ser uma classe que contém propriedades e estas propriedades são atributos privados de uma classe que definem o estado da mesma. Sendo as propriedades privadas, elas só podem ser acessadas dentro de outras classes através de métodos.
Os métodos que são responsáveis por mudar o valor de uma propriedade da classe são chamados de métodos setters e os métodos que retornam o valor de uma propriedade são chamdos de métodos getters.
O nome das propriedades e seus métodos de acesso devem seguir as seguintes regras e convenções:
Para propriedades que não sejam booleana, métodos getters devem ter o prefixo get.
private int size;
public int getSize(){
return this.size;
}
Para propriedades booleanas, métodos getters podem ter o prefixo tanto get como is.
private boolean stopped;
public int isStopped(){
return this.stopped;
}
Métodos setters devem ter prefixo set.
private int size;
public void setSize(int size){
this.size = size;
}
Métodos getters and setters devem ter a o prefixo apropriado (get, set or is) seguido do nome da propriedade, onde a primeira letra deve ser maiúscula.
Métodos setters devem ser públicos, não retornarem nada (void) e receber como argumento o tipo da propriedade que o mesmo corresponde.
Métodos getters devem ser públicos, o retorno deve ser do mesmo tipo da propriedade a que este corresponde e não devem receber nenhum argumento.
Para métodos utilizados para registrar um novo listener o prefixo deve ser add seguido pelo do tipo do listener.
A Sun Microsystems, que foi adquirida pela Oracle, criou um documento chamado Java Code Conventions, a última revisão feita neste documento foi em 1999. Este documento tem como objetivo padronizar a forma de se codificar em Java para facilitar o entendimento de um código por alguém que não seja seu autor, aumentando a legibilidade, clareza e a facilidade de manutenção do mesmo.
Este post abordará padrões de nomes adotados pela convenção.
Classes e Interfaces
Nomes de classes e interfaces devem ter a primeira letra maiúscula, quando o nome é formado por varias palavras, a primeira letra de cada palavra deve ser maiúscula, este formato é conhecido como camelCase . É recomendado evitar o uso de abreviaturas, ao menos que esta seja mais conhecida do que a palavra inteira, ex: URL e HTML.
Para classes, os nomes devem normalmente ser substantivos e para Interfaces normalmente são utilizados adjetivos.
Exemplos:
class Product;
class Person;
class SystemOperation;
interface Runnable;
interface Serializable;
Métodos
Nos métodos, a primeira letra do nome deve ser minúscula e se for composta por outras palavras a forma camelCase deve ser utilizada também. Os nomes são formados geralmente por verbos e podem ser seguidos de substantivos.
getProduct();
changePerson();
run();
Variáveis
Como nos métodos, a primeira letra deve ser minúscula e se for composta por mais de uma palavra, o formato camelCase deve ser utilizado. É recomendado que as variáveis tenham nomes curtos e significativos e que não seja utilizado nome com apenas um carácter exceto para variáveis temporárias.
int i;
String name;
int productNumber;
Constantes
Constantes são marcadas como variáveis static e final. Elas devem ter o nome todo em letra maiúscula e quando composta de mais de uma palavra, etas devem ser separadas por underline (_).
int MAX_NUMBER;
String DEFAULT_LANGUAGE;
Referências:
Java Code Conventions
SCJP Sun® Certified Programmer for Java™ 6 Study Guide
Identificadores são os nomes utilizados para identificar uma variável, método, classe, pacote e/ou uma interface, ou seja, são os próprios nomes dados à eles.
Para que um identificador seja válido ele deve seguir algumas regras:
Devem ser compostos de uma ou mais letras ou números UNICODE-16, no caso do alfabeto latim seria as letras de A-Z e a-z, os dígitos de 0-9 e os símbolos de underline (_) e cifrão($):
Eles devem começar com uma letra, cifrão ou underline, nunca com um número.
Depois do primeiro carácter, ele pode ser composto de qualquer combinação de letras, números, underline e cifrão.
Não há limite de número de carácteres que um identificador pode conter.
Palavras chaves Java não podem ser usadas como identificadores. Ex: class, final, if, etc. Mais abaixo há uma tabela com todas as palavras chaves do Java.
Não se pode utilizar literais que representam tipos lógicos booleanos (true e false).
Não se pode utilizar literais que representa o tipo nulo (null).
Identificadores são case sensitive, sendo assim, A é diferente de a.
Não é permitido caracteres em branco.
Exemplos de identificadores legais:
int _myVariable;
int $myVariable;
int ____my_variable;
int $_;
int this_is_a_valid_identifier;
int MyVariable;
int c;
int _1_2_3;
int __4_u;
Exemplo de identificadores ilegais:
int !myVarieable;
int @b;
int :c;
int d#;
int My Variable;
int 1_2_3;
int 4u;
int _1-2-3;
Para testar copie estes exemplos de identificadores inválidos pra uma classe qualquer e você verá que a classe ficará com erro.
Lista de Palavras Chaves Java.
Referências:
SCJP Sun® Certified Programmer for Java™ 6 Study Guide
The Java Language Specification, Java SE 7 Edition
O que são classes, objetos, estado e comportamento em Java?
Classe
É um modelo ou especificação que descreve o estado (atributos) e o comportamento (métodos) que os objetos criados a partir desta classe irão suportar.
Objeto
O objeto é a instância da classe que é criada em tempo de execução quando a JVM encontra a palavra chave new, quando isso acontece, ele utiliza a classe para criar um objeto. Cada objeto tem seu próprio estado e acesso a todos os comportamentos definidos pela classe.
Estado
É relativo aos atributos da classe. Cada objeto tem seu conjunto próprio de atributos, os quais foram definidos na classe. Os valores atribuídos aos atributos de um objeto definem o seu estado.
Comportamento
São os métodos da classe. Onde os algoritmos são implementados e os dados manipulados. Os métodos definem o comportamento do objeto.
Referência: SCJP Sun® Certified Programmer for Java™ 6 Study Guide
No exemplo mostrado no post anterior, foi utilizado um HashMap com valores pré-definidos para popular os selects. Neste exemplo, será utilizado um método que retornará uma array com os dados filtrados.
O projeto que está sendo utilizado é o mesmo do exemplo do post anterior, sendo assim, não irei postar novamente as libs e as configurações. Para ver o post anterior clique aqui.
Na página index.jsp foi adicionado mais um link para uma outra action:
<h3>A simple example to how use dobleselect from Struts 2!</h3>
<p><s:a action='test' > Go to dobleselect! </s:a></p>
<p><s:a action='prepareLists' > Go to dobleselect 2! </s:a></p>
Este segundo link irá chamar o mótodo prepareLists() da Action CityStateAction. Abaixo segue o código desta action.
public class CityStateAction extends ActionSupport{
private static final long serialVersionUID = -2739421817296013920L;
public ArrayList<State> states;
public ArrayList<City> cities;
@Action("prepareLists")
public String prepareLists(){
states = new ArrayList<>();
cities = new ArrayList<>();
State mg = new State();
mg.setName("Minas Gerais");
mg.setAcronym("MG");
State sp = new State();
sp.setName("São Paulo");
sp.setAcronym("SP");
State rj = new State();
rj.setName("Rio de Janeiro");
rj.setAcronym("RJ");
states.add(mg);
states.add(sp);
states.add(rj);
createCity(mg, "Pouso Alegre");
createCity(mg, "Poços de Caldas");
createCity(mg, "Belo Horizonte");
createCity(sp, "Campinas");
createCity(sp, "Ribeirão Preto");
createCity(sp, "Atibaia");
createCity(rj, "Paraty");
createCity(rj, "Angra dos Reis");
createCity(rj, "Resende");
return SUCCESS;
}
public void createCity(State state, String name){
City city = new City();
city.setName(name);
city.setState(state);
cities.add(city);
}
public ArrayList<City> getCitiesByState(State top){
return populateCitiesList(top);
}
public ArrayList<City> populateCitiesList(State state){
ArrayList<City> citiesByState = new ArrayList<>();
for(City city : cities){
if(city.getState().equals(state)){
citiesByState.add(city);
}
}
return citiesByState;
}
public ArrayList<State> getStates() {
return states;
}
public void setStates(ArrayList<State> states) {
this.states = states;
}
public ArrayList<City> getCities() {
return cities;
}
public void setCities(ArrayList<City> cities) {
this.cities = cities;
}
}
Como nesta action o método que está sendo chamado não é o execute(), é necessário utilizar a annotaion @Action e passar como parâmetro qual action que chamará este método.
O método prepareLists() popula uma lista de Estados contendo três itens: MG, SP e RJ. Ele popula também uma lista de cidades, contendo três cidades para cada um dos três estados.
Para popular a select de cidades que dependerá da select de estados, será utilizado o método getCitiesByState(…), que receberá o estado selecionado e a partir dele retornará uma lista com as cidades que pertencem ao mesmo.
Quando o método prepareLists() retornar SUCCESS a página prepareLists-success será carregada:
<h3>Filling dobleselect lists with a action method</h3>
<s:form action="test">
<s:doubleselect name="state" listKey="name" listValue="name" list="states"
doubleName="city" doubleListKey="name" doubleListValue="name" doubleList="getCitiesByState(top)" label="Choose a State/City">
</s:doubleselect>
</s:form>
No atributo list que corresponde a lista da primeira select, foi passado a lista states que foi populada na Action.
No atributo doubleList é passado o método getCitiesByState(…) da action passando o item que foi selecionado na primeira select.
Página index.jspprepareLists-success.jsp: lista de estadosprepareLists-success.jsp: selecionando as cidades do estado de MG.prepareLists-success.jsp: selecionando o estado de SP na segunda select são carregadas as cidades relacionados a ele.prepareLists-success.jsp: lista de cidades do estado do RJEstrutura do projeto exemplo.
Não é necessário criar um arquivo struts.xml pois será utilizado o plugin de convenção de nomenclatura do Struts 2 ao invés de xml para mapeamento da Action.
No arquivo index.jsp existirá apenas uma mensagem e logo abaixo um link que chamará a o método execute() da action TestAction.
</pre>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!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>Doubleselect Struts 2</title>
</head>
<body>
<h3>A simple example to how use dobleselect from Struts 2!</h3>
<p><s:a action='test' > Go to dobleselect! </s:a></p>
</body>
</html>
<pre>
Pela convenção de nomenclatura padrão do Plugin de Convenção do Struts 2 (struts2-convention-plugin-2.3.4.jar) que está sendo utilizado, esta url irá procurar pela TestAction e chamar o método execute();
Abaixo segue o código da classe TestAction:
package cris.test.action;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.opensymphony.xwork2.ActionSupport;
public class TestAction extends ActionSupport{
private static final long serialVersionUID = 6939102585085668554L;
public List<String> listFruit;
public List<String> listColor;
public String fruitOrColor1;
public String fruitOrColor2;
public Map<String, ArrayList<String>> listCorlorOrFruits;
public String execute(){
listFruit = new ArrayList<>();
listColor = new ArrayList<>();
listFruit.add("Apple");
listFruit.add("Orange");
listFruit.add("Strawberry");
listColor.add("Red");
listColor.add("Blue");
listColor.add("Purple");
listCorlorOrFruits = new HashMap<String, ArrayList<String>>();
listCorlorOrFruits.put("Fruits", (ArrayList<String>) listFruit);
listCorlorOrFruits.put("Colors", (ArrayList<String>) listColor);
return "success";
}
public List<String> getListColor() {
return listColor;
}
public void setListColor(List<String> listColor) {
this.listColor = listColor;
}
public String getFruitOrColor1() {
return fruitOrColor1;
}
public void setFruitOrColor1(String fruitOrColor1) {
this.fruitOrColor1 = fruitOrColor1;
}
public String getFruitOrColor2() {
return fruitOrColor2;
}
public void setFruitOrColor2(String fruitOrColor2) {
this.fruitOrColor2 = fruitOrColor2;
}
public Map<String, ArrayList<String>> getListCorlorOrFruits() {
return listCorlorOrFruits;
}
public void setListCorlorOrFruits(
Map<String, ArrayList<String>> listCorlorOrFruits) {
this.listCorlorOrFruits = listCorlorOrFruits;
}
public List<String> getListFruit() {
return listFruit;
}
public void setListFruit(List<String> listFruit) {
this.listFruit = listFruit;
}
}
Dentro do método execute foi criado duas listas, uma com frutas e outra com cores. Estas listas foram adicionadas dentro de HashMap. Cada lista contém sua chave correspondente no HashMap.
É importante também que os getters and setters sejam colocados na Action. Então o método execute será responsável por preencher as listas.
Este método irá redirecionar para página test-success.jsp que deve estar dentro de WebContent/WEB-INF/content. Abaixo segue o código desta página:
</pre>
<%@ taglib prefix="s" uri="/struts-tags" %>
<%@ 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>Doubleselect Struts 2</title>
</head>
<body>
<h3>Filling dobleselect lists with a HashMap</h3>
<s:form action="test">
<s:doubleselect name="fruitOrColor1" list="listCorlorOrFruits.keySet()"
doubleName="fruitOrColor2" doubleList="listCorlorOrFruits.get(top)" label="Color or Fuits">
</s:doubleselect>
</s:form>
</body>
</html>
Os atributos name e list se referem ao primeiro Select e os atributos doubleName e doubleList se refere ao segundo Select que irá depender do primeiro.
No atributo list está sendo passado as keys do Map e no dobleList está sendo passado o valor das keys que são as arrays.
Então quando for selecionado a opção de frutas a lista de frutas será carregada no segundo select e quando a opção cor for selecionada no primeiro select a lista de cores será carregada.
Abaixo segue imagens do exemplo rodando:
Página index.jspPágina test-success.jsp: Selecionando a opção Fruits a segunda select é preenchida com a lista de frutasPágina test-success.jsp: Selecionando a opção Colors a segunda select é preenchida com a lista de cores.Estrutura do exemplo no eclipse.
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 dadosFormulá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”
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.
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.
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:
Localize em sua máquina onde foi instalado o JDK, geralmente ele fica em C:Arquivos de programasJava, caso não esteje, encontre a pasta Java em seu sistema.
Coloque o nome da variável de JAVA_HOME e seu valor como o caminho do JDK instalado: C:Arquivos de programasJavajdk1.6.0. Confirme o caminho pois a versão do seu JDK pode ser diferente desta. Depois clique em OK.
Após isso clicaremos outra vez em nova para cria outra variável.
Coloque o nome da variável de CLASSPATH e seu valor como .;%JAVA_HOME%\lib\tools.jar queé onde está o jar tools. Depois clique em OK.
Agora localize a variável Path e clique em Edit?
Acrescente ao valor da variável o seguinte: %JAVA_HOME%bin. E clique em OK.
E pronto! Agora é só reiniciar a máquina para que as alterações tenham efeito.
desoriented programming 