Naked ObjectsIntrodução

Osvaldo Kotaro TakaiJoão Eduardo Ferreira (takai,jef)@ime.usp.br

Mini-curso SBBD/SBES – out-2004

Completeza ComportamentalAs pessoas acham que estão usando a OO para projetar e desenvolver sistemas; mas não estão.Elas ignoram o princípio mais fundamental da OO que é a completeza comportamental:

um objeto deve modelar, por completo, o comportamento das coisas que ele representa.

A completeza comportamental é essencial porque ela é a chave para obter o principal benefício da orientação a objetos:

a habilidade de lidar com as mudanças inesperadas nos requisitos.

Separação dos Dados e ProcessosAo invés disso, elas projetam sistemas que separam o processo de seus dados, embora revestidos com linguagens e tecnologias OO.A separação dos processos de seus dados pode estar relacionada principalmente a inércia:

Isto é, as pessoas aprenderam a projetar sistemas dessa forma e têm dificuldades de pensar de outra maneira.

Objeto Dado

Objeto Processo

Objeto

Inércia

Separação dos Dados e ProcessosA inércia individual é reforçada por práticas organizacionais que forçam a separação dos processos de seus dados, mesmo que o projetista de software queira adotar uma abordagem mais pura de OO:

Orientação a processos de negócio.Interfaces de usuário otimizadas a tarefas.Métodos orientados a use-cases.O padrão Model-View-Controller.Desenvolvimento de software baseado em componentes.

Objeto Dado

Objeto Processo

Objeto

Práticas Organizacionais

Separação dos Dados e ProcessosEssas cinco forças são consideradas as melhores práticas da OO.Não se pode simplesmente descartá-las, pois:

São práticas conscientes que claramente geram benefícios.Foram projetadas para reduzir riscos conhecidos no processo de desenvolvimento.

Porém, essas práticas provocam um efeito colateral:

desencorajam o projeto de objetos comportamentalmente completos.

Abordagem alternativa para projetar sistemas

A alternativa é projetar sistemas que tratem os usuários como solucionadores de problemas.Muitos negócios já possuem alguns sistemas que são, por natureza, problemas a serem resolvidos.

Todos os programas de desenho, do PowerPoint aos sistemas CAD/CAE, são desse tipo, assim como as planilhas eletrônicas.

No entanto, na maioria dos negócios, esses sistemas não são considerados ‘tradicionais’.

Abordagem alternativa para projetar sistemas

Os sistemas tradicionais estão normalmente preocupados com o processamento padronizado das transações de negócio, e são otimizados para um conjunto de tarefas, os quais são quase sempre implementados como processos seqüenciais.

The Incredible MachineThe Incredible Machine (www.sierra.com) é um grande exemplo de um sistema de problema a ser resolvido, e que claramente revela sua estrutura orientada a objetos ao usuário.

The Incredible MachineÉ apresentado ao usuário um problema a ser resolvido – neste caso um balão de prata que tem que ser estourado ...

The Incredible Machine... usando algumas das peças disponíveis (objetos), sendo que cada um pode ser inspecionado para revelar suas propriedades físicas e seus comportamentos:

The Incredible MachineInicialmente, nós usamos uma almofada antigravitacionale um bloco de madeira para desviar a bola sobre o êmbolo.

The Incredible Machine… a qual irádetonar o TNT por controle remoto. Usando uma corda e duas polias e um contrapeso, nós ligamos o balde tal que ele pegue a bola:

The Incredible MachineO contra-peso éum balde furado, e quando uma quantidade suficiente de água vazar, o balde e a bola caem sobre a tesoura, liberando o balão, o qual iráestourar quando encostar no alfinete acima:

As ‘melhores práticas’ no projeto de sistemas de negócio contemporâneos dividem uma aplicação em

quatro camadas principais

Apresentação

Aplicação, Processo ou Controlador de Use-Case

Modelo de objetos de domínio

Persistência

Apresentação

Aplicação, Processo ou Controlador de Use-Case

Modelo de objetos de domínio

Persistência

O Padrão Naked Objects elimina a camada controlador encapsulando todas as funcionalidades

de negócio nos objetos entidade

E tem uma camada de apresentação genérica que automaticamente reflete o modelo de objetos de

domínio como uma interface de usuário orientada a objetos

Apresentação

Aplicação, Processo ou Controlador de Use-Case

Modelo de objetos dedomínio

Persistência

Para um sistema standalone, ou para prototipação, étambém possível autogerar a persistência a partir do

mesmo modelo de domínio

Presentation

Aplicação, Processo ou Controlador de Use-Case

Modelo de objetos dedomínio

Persistência

Naked ObjectsIntrodução ao Framework

Naked Objects

O que é?O framework Naked Objects é uma pacote de software open-source que facilita a construção completa de aplicações de negócio a partir de naked objects (objetos comportamentalmente completos).

O que o pacote contém?Um conjunto de classes Java. A mais importante classe desse conjunto é NakedObject, da qual você deriva subclasses para definir cada uma das classes de objetos de negócio (tal como Cliente). As outras classes do pacote fornecem funcionalidades a serem usadas dentro dos objetos de negócio.

O que o pacote contém?Um ambiente de execução, que inclui:

Um mecanismo de visualização que cria, em tempo real, uma representação manipulável pelo usuário de qualquer naked object que o usuário precisar acessar.Um mecanismo de persistência, o qual torna o naked objects persistente via uma classe de persistência específica. O framework já vem com uma classe de persistência que armazena cada naked object como um arquivo XML. Isso ébom para realizar a prototipação rápida, mas não é escalável. Classes de persistência mais sofisticadas devem ser escritas em sistemas reais.

O que o pacote contém?Ambos os mecanismos funcionam de forma autônoma: eles usam um mecanismo comum de reflexão para inspecionar suas definições de objetos de negócio quando necessários. O programador não precisa se preocupar diretamente com os mecanismos de visualização ou de persistência. O ambiente de execução também fornece interface entre os naked objects e outros serviços de infra-estrutura tais como para segurança e autorização.

O que o pacote contém?Um conjunto de frameworks de teste. O framework de testes unitários é uma simples extensão do popular framework JUnit, tratando as capacidades específicas dos naked objects. Existe um framework separado para testes de aceitação, o qual facilita a confecção dos testes de aceitação antes de escrever as funcionalidades (como defende a Extreme Programming). Como a maioria desses cenários de teste representam tarefas comuns executadas pelos usuários, este framework tem a vantagem adicional de poder gerar a documentação do usuário dessas tarefas diretamente a partir da definição dos testes.

O que é necessário para a execução? O Naked Objects precisa do Java versão 1.1 ou superior para a sua execução. Para desenvolver aplicações, será necessário uma IDE ou um JDK.Para executar exemplos, somente o JRE énecessário.É importante assegurar que o Java esteja instalado apropriadamente e que o seguinte comando funcione (digite o comando abaixo na janela comandos do DOS):

java -version

O que é necessário para a execução?Após pressionar <enter>, os detalhes da versão Java deverá aparecer:

java version "1.4.1_02"Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.1_02-b06)Java HotSpot(TM) Client VM (build 1.4.1_02-b06, mixed mode)

Se nada aparecer ou se uma mensagem de erro aparecer, então será necessário instalar ou reinstalar o JDK adequado para o SO em uso.

O que é preciso baixar?Para executar um exemplo para ver como trabalha uma aplicação Naked Objects, baixe o seguinte programa: http://www.nakedobjects.org/downloads/ecs-demo.zip

Para desenvolver uma aplicação Naked Objects, énecessário baixar o framework NakedObjects: http://www.nakedobjects.org/downloads/nakedobjects1_0_2.zip.

Desempacote o arquivo no diretório c:\Para facilitar o desenvolvimento, é interessante utilizar algum ambiente de desenvolvimento Java. No caso, sugere-se o IDE Eclipse.

A idéia básicaA tela a seguir exibe uma aplicação Naked Object típica em uso. É um sistema de declaração de despesas que permite aos empregados preparar e gerenciar a manutenção das despesas.Cada ícone da tela representa um objeto onde os maiores, à esquerda, representam as classes ou tipo de objetos disponíveis no sistema.

A idéia básica

A idéia básicaAs classes de objetos com as quais o usuário pode iniciar o trabalho (criar novas instâncias, encontrar instâncias existentes, etc.) éexibido na janela de classes.Cada ícone representa uma classe.

A idéia básicaNovas instâncias de um objeto podem ser criadas arrastando-se a classe para a área de trabalho.Ou através do menu pop-up acessado com o botão direito do mouse.

A idéia básicaCada objeto criado estádisponível ao usuário e quando exibidos aparecem na área restante da tela.

A idéia básicaCada objeto pode ser visualizado de formas diferentes – coleções pode ser visualizadas como tabelas e listas, Empregados como formulários, etc.

Tabela Lista

Formulário Texto

A idéia básicaCada objeto de negócio também tem um menu que é usado para acessar as capacidades desse objeto. Esse menu pode ser acessado pressionando-se o botão direito sobre o título do objeto.

Título

A idéia básicaOs objetos de valor –texto, número, datas – que um objeto de negócio possui, podem ser editados usando o teclado e o mouse.

Texto

Número (Moeda)

Data

A idéia básicaOs objetos de negócio podem também ser arrastados e soltos sobre outros objetos de negócio ou dentro de campos que permitem esse tipo de objeto (indicado em cor verde).

A idéia básicaPara construir sistemas com base no Naked Objects, o importante é se concentrar nos objetos de negócio – Cliente, Chamada, Pedido, Fatura, Vôo, Aeroporto, Avião, Equipe, etc. – e deixar a interface e persistência para o framework.Esses objetos são definidos como classes Java seguindo um pequeno número de convenções de codificação. A implementação da interface é fornecida pelo Naked Objects.

Exemplo 1A idéia básica

Exemplo 1Vamos supor que temos a missão de construir uma aplicação que gerencie os papéis existentes em um projeto (Programador, Analista, Líder de Projeto, etc.), bem como os empregados que exercem esses papéis.O diagrama de classes em UML é apresentado ao lado:

Empregadonome

Projetonome

criaLíder()

Papelnome

0..*

0..1

0..*

0..1

0..*

0..*

0..*

0..*

Objetos da classe Projeto referenciam objetos da

classe Papel.

Objetos da classe Papel referenciam objetos da

classe Empregado.

Exemplo 1A aparência da aplicação é exibida ao lado:

Exemplo 1Posso criar um novo projeto (instância ou objeto da classe Projeto), simplesmente arrastando-o para uma área livre:

Exemplo 1Agora posso digitar o nome do projeto. Vamos chamá-lo de “River Fisher”.

River Fisher

Exemplo 1Com o cursor do mouse sobre o objeto, agora chamado “RiverFisher”, pressiono o botão direito do mouse para visualizar o menu pop-up. River Fisher

Exemplo 1Seleciono a opção “Criar Lider”, para criar um novo objeto da classe Papel.Por default, essa opção irá, automaticamente, preencher o atributo Nome desse novo objeto com a String: “Líder de Projeto”.

River Fisher

Exemplo 1Quero agora associar um empregado ao papel “Líder de Projeto”.Para isso, arrasto o ícone da classe Empregado para o campo Empregado do objeto Líder de Projeto

essa é uma forma abreviada de criar um objeto.Note que o campo fica esverdeado.

River Fisher

Exemplo 1Para dar um nome ao objeto Empregado recém criado posso, dar um duplo-cliquesobre o ícone do objeto Empregado que aparece no campo Empregado do objeto “Líder de Projeto”.E então, digitar o nome: “Jef”.

River Fisher

Exemplo 1A fim de verificar se o objeto Jef foi de fato criado, basta pressionar o botão direito do mouse sobre o ícone da classe Empregado e selecionar a opção Empregados do menu pop-up.

Isso fará com que todos os objetos pertencentes à classe Empregado sejam mostrados.

River Fisher

Exemplo 1Antes de prosseguir, exercite este exemplo no seu computador e assegure-se de que tenha entendido a metáfora da interface:

“arrastar e soltar”bem como a forma de acessar o menu pop-up.

Para tanto, execute o arquivo:ExecutarExemplo1.bat

O Código da Classe Empregado

Exemplo 1

O Código da Classe EmpregadoComeçando pelo mais simples, vamos criar a classe Empregado.

Empregadonome

Projetonome

criaLíder()

Papelnome

0..*

0..1

0..*

0..1

0..*

0..*

0..*

0..*

O Código da Classe EmpregadoA classe Empregado possui apenas um atributo: nome, supondo que isso seja o suficiente para distinguí-lo.O código completo da classe Empregado que utiliza o framework Naked Objects é exibido ao lado:

Empregadonome

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Empregado extends AbstractNakedObject {private final TextString nome = new TextString();

public TextString getNome() {return nome;

}

public Title title() {return nome.title();

}}

O Código da Classe EmpregadoA indicação de que a classe Empregado é um naked object é realizada estendendo-se a classe Empregado da classe AbstractNakedObject. A classe AbstractNakedObject estádefinida no pacote importado: org.nakedobjects.object.AbstractNakedObject.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Empregado extends AbstractNakedObject {private final TextString nome = new TextString();

public TextString getNome() {return nome;

}

public Title title() {return nome.title();

}}

AbstractNakedObject

Empregadonome

O Código da Classe EmpregadoO atributo nome é do tipo TextString e é utilizado para armazenar informações textuais simples.A definição do tipo TextString está definido no pacote: org.nakedobjects.object.value.TextString.Note que todo atributo de um objeto naked object éexibido pela interface gerada pelo framework Naked Object como um campo, no caso Nome com N maiúsculo.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Empregado extends AbstractNakedObject {private final TextString nome = new TextString();

public TextString getNome() {return nome;

}

public Title title() {return nome.title();

}}

Atributo

Campo

O Código da Classe EmpregadoO atributo nome édeclarado como privatefinal para indicar que ele deve ser inicializado antes de ser usado e que não pode ser diretamente alterado.A alteração somente épermitida pela interface fornecida pelo Naked Objects.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Empregado extends AbstractNakedObject {private final TextString nome = new TextString();

public TextString getNome() {

return nome;}

public Title title() {return nome.title();

}}

Interface

O Código da Classe EmpregadogetNome() é um método public o qual permite que outras classes consultem o conteúdo do atributo nome; no caso Jef.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Empregado extends AbstractNakedObject {private final TextString nome = new TextString();

public TextString getNome() {return nome;

}

public Title title() {return nome.title();

}}

O Código da Classe Empregadotitle() é um método publico qual permite que outras classes consultem o título do objeto.Neste exemplo, o título do objeto é igual ao valor do atributo nome convertido para o tipo Title, que no caso é Jef.Note que o método titleretorna um objeto do tipo Title, o qual estáespecificado em: org.nakedobjects.object.Title .

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Empregado extends AbstractNakedObject {private final TextString nome = new TextString();

public TextString getNome() {return nome;

}

public Title title() {return nome.title();

}}

Título

Conversão de TextString para TitleTítulo

O Código da Classe EmpregadoPara poder testar (ou explorar) essa classe naked object, crie uma classe chamada Run(poderia ter outro nome), como ilustra o código ao lado.Note que a classe Runestende a classe do Naked Objects Exploration que está definida em: org.nakedobjects.Exploration.

import org.nakedobjects.Exploration;import org.nakedobjects.object.NakedClassList;

public class Run extends Exploration {public static void main(String args[]) {

new Run();}

public void classSet(NakedClassList classes) {classes.addClass(Empregado.class);

}}

O Código da Classe EmpregadoA classe Run possui um método chamado main; isso indica ao JVM que o início da execução do programa começa nessa classe.Quando o método main éexecutado, ele cria uma instância de sua própria classe: um objeto Run.

import org.nakedobjects.Exploration;import org.nakedobjects.object.NakedClassList;

public class Run extends Exploration {public static void main(String args[]) {

new Run();}

public void classSet(NakedClassList classes) {classes.addClass(Empregado.class);

}}

O Código da Classe EmpregadoAgora que o objeto Run foi criado, o framework pode, então, chamar o método classSet, o qual adiciona a classe Empregado(addClass) na lista de classes que serádisponibilizado ao usuário.No caso foi acrescentado apenas uma classe: Empregado.

import org.nakedobjects.Exploration;import org.nakedobjects.object.NakedClassList;

public class Run extends Exploration {public static void main(String args[]) {

new Run();}

public void classSet(NakedClassList classes) {classes.addClass(Empregado.class);

}}

O Código da Classe EmpregadoPode-se notar que, embora a classe se chame Empregado, o nome apresentado na lista de classes é Empregados(plural).

O framework sempre faz isso.Por default o framework adiciona automaticamente um ‘s’no final de todos os nomes de classe.Veremos como mudar isso posteriormente.

import org.nakedobjects.Exploration;import org.nakedobjects.object.NakedClassList;

public class Run extends Exploration {public static void main(String args[]) {

new Run();}

public void classSet(NakedClassList classes) {classes.addClass(Empregado.class);

}}

Plural

Singular

O Código da Classe EmpregadoCopie o código da classe Empregado (ao lado) num arquivo com o nome Empregado.java.

Para isso, utilize um editor de textos, por exemplo, o Noteped (Bloco de Notas).O nome do arquivo tem que ser exatamente esse: Empregado.java e não empregrado.java.

Salve o arquivo Empregado.java dentro de um diretório, por exemplo, c:\exemplo1.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Empregado extends AbstractNakedObject{

private final TextString nome = new TextString();

public TextString getNome() {return nome;

}

public Title title() {return nome.title();

}}

O Código da Classe EmpregadoFaça o mesmo com a classe Run:

Copie o código da classe Run (ao lado) num arquivo com o nome Run.java.E salve o arquivo Run.javadentro do mesmo diretório onde estáEmpregado.java, por exemplo, c:\exemplo1.

import org.nakedobjects.Exploration;import org.nakedobjects.object.NakedClassList;

public class Run extends Exploration {public static void main(String args[]) {

new Run();}

public void classSet(NakedClassList classes) {classes.addClass(Empregado.class);

}}

O Código da Classe EmpregadoCrie agora um diretório chamado images.

O Código da Classe EmpregadoCopie do diretório generic-large-icons do framework Naked Objects, o arquivo CallCentreAgent32.gif.

O Código da Classe EmpregadoE cole o arquivo CallCentreAgent32.gif no diretório images.

O Código da Classe EmpregadoCopie agora, do diretório generic-small-icons, o arquivo CallCentreAgent16.gif.E cole-o no diretório images.

O Código da Classe EmpregadoRenomeie os arquivos:

CallCentreAgent32.gifpara Empregado32.gifCallCentreAgent16.gifpara Empregado16.gif

Isso fará com que o framework associe os ícones à classe Empregado.

O Código da Classe EmpregadoPara compilar, digite a seguinte linha de comando na janela DOS e pressione enter.

Isso irá gerar os arquivos:Empregado.classRun.class

O Código da Classe EmpregadoPara executar, digite a seguinte linha de comando e pressione enter.

O Código da Classe EmpregadoApós teclar enter, a capa do livro Naked Objects irá ser exibida e posteriormente, será apresentada a lista de classes contendo apenas a classe Empregado.

O Código da Classe PapelExemplo1

O Código da Classe PapelA classe Papel é criado e disponibilizado da mesma forma que a classe Empregado.Vamos nos concentrar, portanto, em algumas diferenças, tal como a associação da classe Papelcom a classe Empregado.

Empregadonome

Projetonome

criaLíder()

Papelnome

0..*

0..1

0..*

0..1

0..*

0..*

0..*

0..*

Associação

O Código da Classe PapelOs objetos naked objects implementam a associação como um atributo que referencia objetos de uma outra classe naked objects.No caso, a classe Papelterá que manter, no máximo, uma referência àobjetos da classe Empregado (veja a multiplicidade: 0..1).

Multiplicidade

Empregadonome

Projetonome

criaLíder()

Papelnome

0..*

0..1

0..*

0..1

0..*

0..*

0..*

0..*

O Código da Classe PapelAssim, a associação éimplementada como um atributo simples, o qual pode armazenar uma única referência para um objeto da classe Empregado.Posteriormente, veremos como implementar multiplicidades maiores que 1.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Papel extends AbstractNakedObject {private final TextString nome = new TextString();private Empregado empregado;

public TextString getNome() {return nome;

}

public Empregado getEmpregado() {resolve(empregado);return empregado;

}

public void setEmpregado(Empregado empregado) {this.empregado = empregado;objectChanged();

}

public Title title() {return nome.title();

}}

Associação

O Código da Classe PapelComo qualquer atributo de classe, o atributo empregado não pode ser acessado diretamente.A única maneira de acessar um atributo de classe deve ser através dos métodos de acesso denominados set e get.Assim:

getEmpregado() éutilizado para consultar um objeto associado da classe Empregado.setEmpregado() éutilizado para alterar um objeto associado da classe Empregado.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Papel extends AbstractNakedObject {private final TextString nome = new TextString();private Empregado empregado;

public TextString getNome() {return nome;

}

public Empregado getEmpregado() {resolve(empregado);return empregado;

}

public void setEmpregado(Empregado empregado) {this.empregado = empregado;objectChanged();

}

public Title title() {return nome.title();

}}

O Código da Classe PapelO framework Naked Objects reconhece que getEmpregado e setEmpregado são métodos de acesso vinculados ao atributo empregado porque ele utiliza um mecanismo chamado reflexão.Assim, quaisquer métodos que possuam prefixos gete set serão considerados como métodos de acesso a algum atributo existente.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Papel extends AbstractNakedObject {private final TextString nome = new TextString();private Empregado empregado;

public TextString getNome() {return nome;

}

public Empregado getEmpregado() {resolve(empregado);return empregado;

}

public void setEmpregado(Empregado empregado) {this.empregado = empregado;objectChanged();

}

public Title title() {return nome.title();

}}

O Código da Classe PapelO método getEmpregado() é implementado chamando o método resolve(empregado) do framework.

O método resolveassegura que um objeto referenciado seja recuperado corretamente do repositório de objetos.Após o método resolve, carregar para a memória um objeto da classe Empregado, referenciado pelo atributo empregado, essa referência éretornada.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Papel extends AbstractNakedObject {private final TextString nome = new TextString();private Empregado empregado;

public TextString getNome() {return nome;

}

public Empregado getEmpregado() {resolve(empregado);return empregado;

}

public void setEmpregado(Empregado empregado) {this.empregado = empregado;objectChanged();

}

public Title title() {return nome.title();

}}

O Código da Classe PapelO método setEmpregado () é implementado:

Atualizando o atributo da classe Papel: empregado, com a referência passada pelo parâmetro empregado.Depois disso, o método objectChanged() do framework é chamado. O método objectChanged() informa aos mecanismos de visualização e de persistência que o status do objeto da classe Papel foi alterado.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Papel extends AbstractNakedObject {private final TextString nome = new TextString();private Empregado empregado;

public TextString getNome() {return nome;

}

public Empregado getEmpregado() {resolve(empregado);return empregado;

}

public void setEmpregado(Empregado empregado) {this.empregado = empregado;objectChanged();

}

public Title title() {return nome.title();

}}

O Código da Classe PapelCopie o código da classe Papel (ao lado) num arquivo com o nome Papel.java.

E salve esse arquivo dentro do mesmo diretório onde estáEmpregado.java e Run.java foram salvos. Por exemplo, c:\exemplo1.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Papel extends AbstractNakedObject {private final TextString nome = new TextString();private Empregado empregado;

public TextString getNome() {return nome;

}

public Empregado getEmpregado() {resolve(empregado);return empregado;

}

public void setEmpregado(Empregado empregado) {this.empregado = empregado;objectChanged();

}

public Title title() {return nome.title();

}}

O Código da Classe PapelModifique a classe Run, para que ela adicione a classe Papel na lista de classes.

import org.nakedobjects.Exploration;import org.nakedobjects.object.NakedClassList;

public class Run extends Exploration {public static void main(String args[]) {

new Run();}

public void classSet(NakedClassList classes) {classes.addClass(Empregado.class);classes.addClass(Papel.class);

}}

Adicionado

O Código da Classe PapelCopie o arquivo Hammer16.gif e Hammer32.gif para o diretório c:/Exemplo1/images.

O Código da Classe PapelRenomeie os arquivos:

Hammer16.gif para Papel16.gifHammer32.gif para Papel32.gif.

O Código da Classe PapelCompile:

Execute:

O Código da Classe PapelAo executar, a lista de classes ao lado irá ser exibida.Agora é possível criar objetos da classe Papel e associá-los á objetos da classe empregado.

O Código da Classe PapelUma coisa que estáincomodando é o nome da classe exibida na lista de ícones: Papels.Para corrigir esse problema, podemos informar ao framework qual é o plural correto de Papel, que no caso éPapéis.

Nome da classe + ‘s’

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Papel extends AbstractNakedObject {private final TextString nome = new TextString();private Empregado empregado;

public static String pluralName() {return "Papéis";

}

public TextString getNome() {return nome;

}public Empregado getEmpregado() {

resolve(empregado);return empregado;

}public void setEmpregado(Empregado empregado) {

this.empregado = empregado;objectChanged();

}public Title title() {

return nome.title();}

}

O Código da Classe PapelPara isso, acrescente o seguinte método pluralName como ilustra código ao lado:Após compilar e executar novamente, a seguinte lista de ícones seráexibida:

Com o plural correto

O Código da Classe ProjetoExemplo1

Código da classe ProjetoA classe Projeto é criada e disponibilizada da mesma forma que as classes Empregado e Papel.Vamos nos concentrar, portanto, em algumas diferenças, tal como a associação de multiplicidade 0..* entre as classes Projeto e Papel, e na criação do método criaLider exibida como uma das opções do menu pop-up.

Empregadonome

Projetonome

criaLíder()

Papelnome

0..*

0..1

0..*

0..1

0..*

0..*

0..*

0..*Associação

Multiplicidade

Código da classe ProjetoPara facilitar a visualização, as diretivas de importação ao lado serão omitidas do código.

import java.util.Enumeration;import org.nakedobjects.object.collection.InternalCollection;import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.control.About;import org.nakedobjects.object.control.ActionAbout;import org.nakedobjects.object.value.Case;import org.nakedobjects.object.value.TextString;

Código da classe ProjetoA classe Projeto pode conter múltiplos objetos da classe Papel.

Para isso, o tipo InternalCollection do framework foi utilizado.

O tipo InternalCollectionpermite guardar uma coleção de objetos de um tipo indicado.

Neste caso, o tipo indicado é a classe Papel.A palavra this é também passada como parâmetro para indicar que a classe Papel estácontida nesta instância da classe Projeto.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Código da classe ProjetoComo qualquer atributo de classe, o atributo papeis é private final.Ele possui também um método get, permitindo que a coleção, com referências a objetos da classe Papel, possa ser consultada pelo framework utilizando o mecanismo de reflexão.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Lista de objetos

da classe Papel

Código da classe ProjetoSó para recordar, a opção Cria Lider deve estar acessível pressionando-se o botão direito do mouse sobre o título de um objeto da classe Projeto.Ao selecionar essa opção, um novo objeto da classe Papel será criado automaticamente com o campo Nome jápreenchido.

Campo nome preenchido automaticamente

Código da classe ProjetoA opção Cria Lider éimplementada através dos métodos de ação (action method).O framework adiciona uma opção no menu pop-up automaticamente para todo o método que comece com a palavra actionCriaLider.Assim, quando o usuário seleciona a opção Cria Lider do menu pop-up, o método actionCriaLider éexecutado.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Código da classe ProjetoQuando o método actionCriaLider éexecutado, ele cria uma nova instância da classe Papel através do método createInstance.Instâncias de classes naked objects não devem ser criadas usando o operador padrão new da linguagem Java – isso não irá inicializá-lasapropriadamente.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Código da classe ProjetoA referência para a nova instância de classe Papelfoi guardada na variável lideDeProjeto.O nome desse novo objeto é inicialmente obtido usando o método getNome.O método getNomeretorna o objeto da classe TextString, o qual define o método setValue. Enfim, o método setValuepermite alterar o nome do novo objeto para “Líder de Projeto”.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Código da classe ProjetoO objeto da classe Papel, recém criado, com o nome “Líder de Projeto” éadicionado à coleção de papeis associados ao objeto da classe Projeto.No final, o objeto liderDeProjeto éretornado.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Código da classe ProjetoO próximo método, aboutActionCriaLider, éexecutado sempre que o menu pop-up é acionado pelo usuário.O framework, antes da construção do menu pop-up, verifica se existe algum método aboutActionCriaLidercorrespondente ao método actionCriaLider.Como existe, o framework executa o método aboutActionCriaLider.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Código da classe ProjetoO objetivo do método aboutActionCriaLider édesabilitar a opção “Cria Lider” do menu pop-up, caso já exista um objeto papel com o nome “Líder de Projeto”; caso contrário, a opção éhabilitada.Para tanto, ele percorre a coleção de objetos Papelem busca de um objeto com o nome “Líder de Projeto”; se encontrar, ele desabilita a opção retornando ao framework o ActionAbout.DISABLE; se não retorna ActionAbout.ENABLE.

public class Projeto extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection papeis = new InternalCollection(Papel.class, this);

public TextString getNome() {return nome;

}public InternalCollection getPapeis() {

return papeis;}public Papel actionCriaLider() {

Papel liderDeProjeto = (Papel) createInstance(Papel.class);liderDeProjeto.getNome().setValue("Líder de Projeto");papeis.add(liderDeProjeto);return liderDeProjeto;

}public About aboutActionCriaLider() {

Enumeration e = getPapeis().elements();while (e.hasMoreElements()) {

Papel role = (Papel) e.nextElement();if (role.getNome().contains("líder de projeto", Case.INSENSITIVE)) {

return ActionAbout.DISABLE;}

}return ActionAbout.ENABLE;

}public Title title() {

return nome.title();}

}

Associações BidirecionaisAssunto Específico

Associações BidirecionaisAté agora nós consideramos a maneira de como um objeto conhece um outro objeto – uma associação de um caminho.

Normalmente isso é suficiente; algumas vezes o objeto que está sendo referenciado também precisa conhecer o objeto que o referencia. Tome, por exemplo, um sistema de pedidos. Um objeto pedido normalmente conterá uma referência para o cliente que fez o pedido. No entanto, pode ser útil conseguir obter, a partir de um objeto cliente, o seu pedido atual, talvez até o acesso a todos os seus pedidos. Para permitir isso, o cliente precisa manter referências a objetos pedido. Isso pode ser obtido adicionando um campo à classe cliente, contendo ou um único objeto pedido, ou uma coleção de pedidos.

Associações BidirecionaisPara ilustrar como implementar associações bidirecionais, considere o diagrama de classes muito simples, o qual modela os seguintes conceitos:

um cliente pode ter zero ou mais pedidos.e que, sempre que existir um pedido, ele possui obrigatoriamente um único cliente.

Clientenome

Pedidonumerodescricao

0..*

11

0..*

Associação bidirecional

Associações BidirecionaisQuando a associação érealizada soltando-se um objeto pedido sobre o campo Pedidos de um objeto cliente, quem recebe essa ação é o objeto cliente.A classe Cliente éimplementada:

Definindo uma coleção pedidos (nada de novo).Definindo o método de acesso getPedidos (nada de novo).Definindo os métodos de associação:

associatePedidosdissociatePedidos

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.collection.InternalCollection;import org.nakedobjects.object.value.TextString;

public class Cliente extends AbstractNakedObject {private final TextString nome= new TextString();private final InternalCollection pedidos = new

InternalCollection(Pedido.class, this);

public TextString getNome() {return nome;

}public final InternalCollection getPedidos() {

return pedidos;}public void associatePedidos(Pedido pedido) {

getPedidos().add(pedido);pedido.setCliente(this);

}public void dissociatePedidos(Pedido pedido) {

getPedidos().remove(pedido);pedido.setCliente(null);

}public Title title() {

return nome.title();}

}

Associações BidirecionaisO método associatePedidos:

Recebe o objeto pedidoatravés do seu parâmetro.Insere o objeto pedido em sua coleção de pedidos.Solicita ao objeto pedidoque ele acerte a sua referência ao cliente para this (referência para o próprio objeto da classe Cliente).

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.collection.InternalCollection;import org.nakedobjects.object.value.TextString;

public class Cliente extends AbstractNakedObject {private final TextString nome= new TextString();private final InternalCollection pedidos = new

InternalCollection(Pedido.class, this);

public TextString getNome() {return nome;

}public final InternalCollection getPedidos() {

return pedidos;}public void associatePedidos(Pedido pedido) {

getPedidos().add(pedido);pedido.setCliente(this);

}public void dissociatePedidos(Pedido pedido) {

getPedidos().remove(pedido);pedido.setCliente(null);

}public Title title() {

return nome.title();}

}

Associações BidirecionaisA remoção de uma associação de um objeto pedido com o seu objeto cliente pode ser realizada através da opção pop-upRemove reference.Quando essa opção éacionada, o método dissociatePedidos entra em ação:

Removendo o objeto pedido da coleção de pedidos.Solicitando ao objeto pedido limpe a sua referência ao cliente atribuindo o valor null.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.collection.InternalCollection;import org.nakedobjects.object.value.TextString;

public class Cliente extends AbstractNakedObject {private final TextString nome= new TextString();private final InternalCollection pedidos = new

InternalCollection(Pedido.class, this);

public TextString getNome() {return nome;

}public final InternalCollection getPedidos() {

return pedidos;}public void associatePedidos(Pedido pedido) {

getPedidos().add(pedido);pedido.setCliente(this);

}public void dissociatePedidos(Pedido pedido) {

getPedidos().remove(pedido);pedido.setCliente(null);

}public Title title() {

return nome.title();}

}

Associações BidirecionaisQuando a associação érealizada soltando-se um objeto cliente sobre o campo cliente do objeto pedido, quem recebe essa ação é o objeto pedido.A classe Pedido éimplementada:

Definindo um atributo cliente (nada de novo).Definindo o método de acesso getCliente e setCliente (nada de novo).Definindo os métodos de associação:

associateClientedissociateCliente

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Pedido extends AbstractNakedObject {private final TextString numero = new TextString();private Cliente cliente;

public Cliente getCliente() {resolve(cliente);return cliente;

}public void setCliente(Cliente novoCliente) {

cliente = novoCliente;objectChanged();

}public TextString getNumero() {

return numero;}public void associateCliente(Cliente cliente) {

cliente.associatePedidos(this);}public void dissociateCliente(Cliente cliente) {

cliente.dissociatePedidos(this);}public Title title() {

return numero.title();}

}

Associações BidirecionaisOs métodos associateCliente e dissociateCliente são implementados apenas chamando os métodos anteriormente definidos na classe Cliente.

import org.nakedobjects.object.AbstractNakedObject;import org.nakedobjects.object.Title;import org.nakedobjects.object.value.TextString;

public class Pedido extends AbstractNakedObject {private final TextString numero = new TextString();private Cliente cliente;

public Cliente getCliente() {resolve(cliente);return cliente;

}public void setCliente(Cliente novoCliente) {

cliente = novoCliente;objectChanged();

}public TextString getNumero() {

return numero;}public void associateCliente(Cliente cliente) {

cliente.associatePedidos(this);}public void dissociateCliente(Cliente cliente) {

cliente.dissociatePedidos(this);}public Title title() {

return numero.title();}

}

Campos DerivadosAssunto Específico

Campos DerivadosSe um campo precisar ser derivado dinamicamente a partir de outros campos dentro do objeto, então é melhor usar o prefixo ‘derive’ao invés de ‘get’. Isso tornará o campo somente-leitura e não-persistente, evitando qualquer potencial problema que possa surgir quando o mecanismo de persistência tentar armazenar ou recuperar este campo do repositório.

Campos DerivadosPara demonstrar a implementação de um campo derivado, vamos estender o exemplo anterior adicionando um atributo quantidadeDePedidos na classe Cliente.O objetivo do campo derivado quantidadeDePedidos éexibir a quantidades de pedidos associados a um objeto cliente sempre que um pedido for adicionado ou removido.

Pedidonumerodescricao

ClientenomequantidadeDePedidos

1

0..*0..*

1

Campos DerivadosO atributo QuantidadeDePedidos édeclarado como um número integral do framework NakedObjects (WholeNumber) iniciado com 0.

public class Cliente extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection pedidos = new

InternalCollection(Pedido.class, this);private WholeNumber QuantidadeDePedidos=new

WholeNumber(0);

public TextString getNome() {return nome;

}public final InternalCollection getPedidos() {

return pedidos;}public WholeNumber deriveQuantidadeDePedidos() {

return QuantidadeDePedidos;}public void associatePedidos(Pedido pedido) {

getPedidos().add(pedido);pedido.setCliente(this);QuantidadeDePedidos.add(1);objectChanged();

}public void dissociatePedidos(Pedido pedido) {

getPedidos().remove(pedido);pedido.setCliente(null);QuantidadeDePedidos.subtract(1);objectChanged();

}public Title title() {

return nome.title();}

}

Campos DerivadosPara indicar que QuantidadeDePedidos é um campos Derivado, o método deriveQuantidadeDePedidos foi definido.Esse método apenas retorna o valor de QuantidadeDePedidos.

public class Cliente extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection pedidos = new

InternalCollection(Pedido.class, this);private WholeNumber QuantidadeDePedidos=new

WholeNumber(0);

public TextString getNome() {return nome;

}public final InternalCollection getPedidos() {

return pedidos;}public WholeNumber deriveQuantidadeDePedidos() {

return QuantidadeDePedidos;}public void associatePedidos(Pedido pedido) {

getPedidos().add(pedido);pedido.setCliente(this);QuantidadeDePedidos.add(1);objectChanged();

}public void dissociatePedidos(Pedido pedido) {

getPedidos().remove(pedido);pedido.setCliente(null);QuantidadeDePedidos.subtract(1);objectChanged();

}public Title title() {

return nome.title();}

}

Campos DerivadosO atributo QuantidadeDePedidos éincrementado de 1 quando o cliente é associado a um novo pedido e decrementado de 1 quando a associação éremovida.Após QuantidadeDePedidossofrer alteração é necessário executar o método objectChanged. O objectChanged informa ao mecanismo de visualização ou de persistência que o status do objeto foi alterado.

public class Cliente extends AbstractNakedObject {private final TextString nome = new TextString();private final InternalCollection pedidos = new

InternalCollection(Pedido.class, this);private WholeNumber QuantidadeDePedidos=new

WholeNumber(0);

public TextString getNome() {return nome;

}public final InternalCollection getPedidos() {

return pedidos;}public WholeNumber deriveQuantidadeDePedidos() {

return QuantidadeDePedidos;}public void associatePedidos(Pedido pedido) {

getPedidos().add(pedido);pedido.setCliente(this);QuantidadeDePedidos.add(1);objectChanged();

}public void dissociatePedidos(Pedido pedido) {

getPedidos().remove(pedido);pedido.setCliente(null);QuantidadeDePedidos.subtract(1);objectChanged();

}public Title title() {

return nome.title();}

}

Exemplo de Booking

Exemplo: BookingO ECS (Executive Car Services – Serviços Carros Executivos) é uma grande empresa de limusine com uma central de chamadas servindo operações em múltiplas cidades.

Embora a empresa goze de excelente reputação no serviço ao cliente, a abordagem da central de chamadas padrões de tentar cobrir todas as interações do cliente usando roteiros otimizados e padrões pode, algumas vezes, causar consideráveis frustrações – tanto do cliente quanto do agente de reservas.

Exemplo: BookingA maior frustração é quando a cliente precisa de um resultado intermediário para ser capaz de responder uma questão:

Cliente: Quanto tempo leva para sair de São Paulo e chegar à Bahia? Agente: Em que dia você pretende sair de São Paulo? Cliente: Isso depende de quanto tempo se leva para chegar à Bahia ...

Esta abordagem de forçar o roteiro para as interações está se tornando muito comum (e frustrante).

Exemplo: BookingSolução Naked Objects: O agente como um solucionador de problemas:

FAQ’sQuais tipos de sistemas de negócio se beneficiam quando projetados como naked objects?

Os naked objects funcionam bem sempre que:É reconhecido que o sistema de negócio resultante precisa apoiar uma forma de resolver problemas.Existir consideráveis incertezas nos requisitos de negócio para o sistema.Nós podemos argumentar que ambos se aplicam a qualquer projeto de novos sistemas, mas o grau varia.

FAQ’sA expressividade não se contrapõe à eficiência de negócio?

Se você tem uma tarefa absolutamente padronizada, então fornecer ao usuário várias formas de realizar essa tarefa será menos eficiente do que otimizar o sistema para uma melhor solução. Mas a razão de tarefas não-padrão para padrão écrescente, porque problemas que podem ser completamente padronizados estão ou sendo totalmente automatizadas, removendo o ser humano do laço, ou, através do uso de tecnologias auto-serviço, os quais estão sendo delegados aos usuários fora da organização.O exército de secretários que realizam grandes volumes de tarefas de ‘entrada de dados’ estão desaparecendo rapidamente.

FAQ’sSeu pessoal está usando esse estilo de sistema?

Ninguém quer mais responsabilidade ou maior liberdade de expressão. Alguns podem preferir uma posição confortável de não ter que pensar. Mas gerentes de negócio não devem tirar conclusões precipitadas sobre isso. Como um gerente de sistemas de um banco nos disse durante uma entrevista:

‘Por anos nós dizemos aos usuários para não fazer qualquer coisa a menos que esteja expresso em termos de sete principais transações que o nosso sistema mainframe de banco pode realizar. Agora nós temos este sistema beneficiário-servidor, todos cantando e dançando com um uma interface de usuário enfeitada e adivinhe o que os usuários estão se queixando: que eles não sabem o que fazer com eles. Nós tiramos deles toda a criatividade!’.

FAQ’sO conceito completo de naked objects indubitavelmente incorpora uma visão otimista das capacidades do usuário. Ele não é bom para tudo. Mas nós achamos que a filosofia oposta é terrível de considerar.

No final do trabalho, nós devemos reconhecer que qualquer transição para um estilo de trabalho mais poderoso exige maior educação, e pode ditar um período transitório onde exista maior guia e controle. Como dissemos anteriormente, se você projetar um sistema a partir dos naked objects, então é sempre possível construir uma camada de procedimentos roteirizadas no topo desses objetos – de fato eles são muito fáceis de escrever. Mas se você projetar um sistema ao redor dos procedimentos roteirizados, você irá achar muito mais difícil tornar o sistema mais expressivo posteriormente.

FAQ’sComo podemos ainda implementar controles de negócio necessários?

Com os naked objects esses controles ou restrições devem ser implementados dentro dos objetos de negócio para os quais eles se aplicam. Por contraste, muitos sistemas de negócio reforçam controles no nível de interações roteirizadas. O reforço no nível de objetos de negócio não dá aos usuários maior liberdade de chamar objetos na ordem que melhor satisfaça o problema que eles estão resolvendo, mas na prática permite um forte nível de controle.

FAQ’sComo você contorna a necessidade de caixas de diálogos?

A solução é implementar o conceito manipulado na caixa de diálogo como uma classe de objeto com seus próprios direitos.

FAQ’sComo o Naked Objects atende aos requisitos de múltiplas visões?

O framework Naked Objects permite que você personalize as visões através do uso de objetos About(sobre) – você pode especificar quais atributos, associações e métodos serão disponibilizados para um dado usuário ou papel. O mesmo mecanismo pode ser usado para controlar a visão, ou comportamento, de um objeto de acordo com o seu estado (onde este estado éou representado explicitamente, ou derivado de outros atributos e associações).

FAQ’sMas, em geral, a idéia de projetar sistemas a partir de naked objects é evitar tanto quanto a contextualização.O objetivo é dar ao usuário uma visão potencialmente rica de objetos quando possível, a menos que a tela fique muito confusa. É este o contraste marcante na abordagem usual de projetar sistemas, a qual dá ao usuário o mínimo necessário de informação para completar uma particular tarefa, limitando a oportunidade dos usuários aprenderem a enxergar todo o contexto.

FAQ’sUm efeito colateral positivo dos naked objects é que eles ajudam a preservar a integridade do modelo do objeto.Por exemplo, um sistema convencionalmente projetado pode exibir num pedido, o nome e o endereço do beneficiário, o qual teria sido extraído do objeto Beneficiário. Enquanto que isso não transgride a regra de encapsulamento no sentido técnico, é certamente danoso para o entendimento do modelo do objeto do usuário. Usando naked objects, o Pedido não exibe o nome e o endereço do beneficiário como campos separados: ele irá exibir um ícone representando o Beneficiário dentro do Pedido. Para verificar, ou alterar o endereço do beneficiário, o usuário pode abrir o objeto beneficiário e fazer a alteração ali mesmo.

FAQ’sComo você evita que objetos compartilhados fiquem ‘inchados?

Um objeto com muitos métodos, atributos e associações cheira como um programa monolítico – sugerindo que a agilidade seja reduzida. A resposta, em muitos casos é usar a técnica de agregação:

Quebre o objeto em componentes naturais, mesmo se esses componentes nunca sejam acessados fora do contexto de seus objetos pais, e agregue tais componentes.

FAQ’sO Naked Objects pode funcionar dentro de uma arquitetura ‘cliente magro’?

Acreditamos que a idéia de ‘cliente magro’ precisa ser contestada. Quando proposta inicialmente, a idéia de executar todas as coisas dentro de um browser tem considerável apelo, devido a eliminar a necessidades de manter o software diretamente sobre máquinas clientes. Mas existem agora muitos meios técnicos de alcançar esta meta. Uma outra motivação foi fornecer um ambiente de interface de usuário padronizado, mas, como nós temos visto, existem poucas padronizações no modelo de interação de usuário oferecido pelas diferentes aplicações baseadas em browser.

FAQ’sMais ainda, a interface HTML básica não é uma boa interface para realizar alguns tipos de atividades problema-solução. O browser tinha a intenção de apenas publicar informações. Capacidades transacionais tiveram que gradualmente ser adicionados, mas eles são algo como um “quebra galho” em termos de projeto de interface de usuário. A terceira motivação para a padronização sobre uma interface de browser é para acesso do consumidor. No entanto, os naked objects são melhores adaptados para aplicações de uso freqüente, os quais antes de tudo pensam nos usuários domésticos.

FAQ’sOs Naked Objects permitem que usuários desenvolvam suas próprias aplicações?

Nós pensamos que o empreendimento de tornar a programação uma operação totalmente gráfica seria desviar dos objetivos. Seria voltado para que usuários finais pudessem programar; mas é isso que nós precisamos? Os naked objects foram concebidos para apoiar a solução de problemas pelos usuários finais, não para a programação pelos usuários finais. Resolver problemas significa encontrar uma solução para um contexto específico único.

FAQ’sA programação envolve encontrar uma solução abstrata para uma classe completa de problemas. Existem habilidades diferentes. Uma planilha é uma ferramenta extraordinariamente poderosa para solucionar problemas individuais e ésimples de usar, mas escrever um modelo de planilha que seja suficientemente robusta para outros usarem requer um grau elevado e diferenciado de disciplina. É isso o que nós queremos que os usuários finais façam?

Limites1. Não há tratamento adequado para as regras de

negócio.

2. Não trata visões de objetos de acordo com os papéis dos usuários.

3. Não trata da evolução do modelo.

4. Não trata adequadamente objetos originados de associações entre objetos. Por exemplo Transferência de valores entre Contas bancárias.

FIM