Arquitetura

Partindo do propósito mais negócio, menos TI, foi desenhado e pensado um modelo antes mesmo de se construir o VSet Chameleon. Esse modelo deveria incorporar a simplicidade do VSet nos quesitos de desenvolvimento e na arquitetura, além de garantir a sustentabilidade do software e do seu legado. Dessa forma, seria possível fugir da "obsolescência programada" causada por mudança de soluções disruptivas e inovações tecnológicas que surgem ao decorrer do tempo no mundo de TIC.

Foi projetada baseada na arquitetura SOA e ESB, com as características de um framework, tornando-se um middleware transacional, VSet Chameleon. Também foi incorporado o conceito de sistema distribuído, SAAS, PAAS e Hot deploy. A integração dos componentes com o “core” do VSet Chameleon acontece por meio de interfaces, permitindo agregar novas funcionalidades sem perder a sua essência. O VSet Chameleon possui interfaces para protocolos de comunicação, formatos de mensagem, conversão de serviços, layout de arquivos, RFID e dispositivos de automação de processos. O “core” do VSet Chameleon abstrai toda a complexidade de infraestrutura permitindo ao desenvolvedor cuidar apenas dos processos de negócios.

Com a implementação da arquitetura MVC no VSet Chameleon, permitiu-se separar a camada de negócio das camadas de apresentação e de dados.

Na prática, o VSet Chameleon é um framework, middleware transacional, orquestrador e coreografia de processos e suas respectivas regras de negócios. Como já mencionado, foi projetado baseado na arquitetura SOA, ou seja, orientada a serviços. É um repositório de regras de negócios, onde o desenvolvedor não se preocupa com a camada de infraestrutura (conexão, banco de dados, serviços, rastreamento), permitindo que o foco principal do desenvolvedor seja a implementação da regra de negócio.

Fluxo de Requisição no VSet Chameleon

Para garantir a sua sustentabilidade, inovações e evolução, foi criado um conceito de "pipeline of chain" onde cada pipeline é responsável por uma determinada atividade e/ou tarefa sem afetar ou quebrar o processo das atividades e/ou tarefas da cadeia dos pipelines. As pipelines interagem entre elas para garantir as funcionalidades do processo como todo e são independentes umas das outras.

Eis pipelines na arquitetura do VSet Chameleon conforme na figura Fluxo de Requisição no VSet Chameleon:

package - responsável pelo processo de empacotamento e desempacotamento de dados;
security control - responde a questão sobre controle de segurança;
Processboard - responsável pela execução do processo.

A implementação do conceito de "pipeline of chain", permite que o VSet Chameleon se adapte com as possíveis mudanças ou inovações tecnológicas no mercado sem perder o seu legado.

O desenvolvedor pode implementar pipeline security control, por exemplo, no novo algoritmo sem afetar o processo das demais pipelines.

Modelo

Foram concebidas no VSet Chameleon duas bases de execução de processos de negócio: “sob demanda” ou “sob serviço”.

Sob demanda: o VSet Chameleon executa o processo a partir de uma requisição qualquer por meio de um canal (Web, mobile, legado).
Sob serviço: o VSet Chameleon executa os processos na forma background e/ou batch, de acordo com os parâmetros definidos.

É importante considerar que em sua estrutura organizacional, permitiu-se incorporar módulos de negócios ou projetos no repositório de classes de negócio ou serviço, onde o VSet Chameleon realiza a sua orquestração ou a sua coreografia dos processos de negócio. Com essa abordagem, várias equipes de projeto podem desenvolver seus negócios simultaneamente sem afetar um ao outro.

Orquestração ocorre quando existe um processo mestre que irá orquestrar o fluxo dos processos participantes.
Coreografia é quando os processos são executados na forma independentes ou simultaneamente até a sua conclusão.

Nota: VSet Chameleon tem sua biblioteca de classes OO que foram implementadas com a finalidade de aumentar a produtividade e a qualidade do desenvolvimento de sistemas. As suas principais classes OO são voltadas para a manipulação de dados por meio de banco de dados e arquivos, para a confecção de relatórios de vários formatos e para a conversão de tipos de mensagens diferentes. Elas serão explicadas posteriormente.

Cada módulo de negócio ou projeto pode implementar a classe InitializeWrapper que tem a funcionalidade de inicializar algo necessário antes do VSet Chameleon carregar o seu próprio módulo de negócio.

No processo de carregamento dos módulos de negócio no VSet Chameleon, as classes de serviços são verificadas de acordo com seus parâmetros. Para aquelas que solicitam a inicialização imediata do serviço ou agendamento, o VSet Chameleon as inicializará ou agendará.

Toda vez que é executado o processo de orquestração no VSet Chameleon é ativado o contexto transacional para garantir a integridade do processo como um todo.

Processo de negócio

"Processo de Negócio é o conjunto de atividades ou tarefas que são estruturadas e geram um valor agregado para o cliente, por meio da entrega de um serviço ou produto. Ele detalha O QUE deve ser realizado, COMO deve ser realizado e QUEM é o responsável" (Michael Porter).

Na classificação, existem três tipos de processos de negócio:

Processos Primários - são aqueles que abrangem as atividades essenciais que uma organização precisa realizar para cumprir sua missão de negócio. Está diretamente relacionada à experiência do usuário. Podem também ser chamados de Atividades Fins ou Processos Finalísticos
Processos de Suporte - são aqueles que dão apoio ou facilitam a execução dos Processos Primários.
Processos de Gestão ou Gerenciamento - são aqueles que medem, monitoram e controlam as atividades de uma organização. Às vezes interpretam como os Processos de Suporte, mas se diferenciam pois não agregam valor ao cliente, mas a outros processos, como os Processos Primários e os Processos de Suporte.

Uma das preocupações do VSet Chameleon é viabilizar o processo de negócio do cliente para que esse tenha êxito, com qualidade, eficiência, eficácia, efetividade e economicidade. Como processo de negócio, é um conjunto de atividades que ocorrem com o objetivo de gerar um produto ou serviço. Partindo dessa premissa, o VSet Chameleon, atuando como orquestrador ou coreografia de processos, construiu uma abordagem de mapear cada atividade ou tarefa do processo de negócio como classe de negócio.

Classe de negócio BusinessProcessWrapper é um componente de regra de negócio de uma atividade ou tarefa de um determinado módulo hospedado na biblioteca de classe de negócio do VSet Chameleon.

Classe de Negócio

Como já visto, o foco principal do desenvolvedor é implementar as regras de negócio de acordo com os requisitos definidos pelos gestores de negócio.

Partindo da premissa da simplicidade, a ideia é criar em uma única classe de negócio, que possibilite a execução de todos os cenários possíveis que podem ocorrer para atender um determinado requisito do negócio. Inspiramos no modelo mais elementar para construção da classe de negócio, conforme na figura Fluxo de Processamento do VSet Chameleon.

A classe de negócio foi concebida no conceito de processo no qual qualquer atividade, ou conjunto de atividades, que tenha ou não uma entrada, agrega algum valor e fornece ou não uma saída. Em nível mais abstrato, a atividade processa ou transforma algo a partir de uma entrada gerando uma saída.

Fluxo de Processamento do VSet Chameleon

Foi implementado o ciclo de execução da classe de negócio em fases (métodos) executados pelo VSet Chameleon com intuito de oferecer flexibilização, organização e clareza para o desenvolvedor implementar suas regras de negócios. Eis as fases (métodos):

builtIn - implementa atividades quando é iniciada a instância da classe;
enhancementLayer - implementa alguma atividade antes de processar o método validate(). O principal objetivo é implementar alguma atividade ou rotina de melhoria como por exemplo: segurança;
validate - implementa o que tange validação necessária de algo
beforeProcess - implementa alguma atividade antes de processar o método process();
process - implementa a regra de negócio propriamente dita;
afterProcess - implementa alguma atividade ou rotina após a execução do método process();
finalize - implementa alguma atividade ou rotina para finalização;
rollback - implementa alguma atividade ou rotina de desfazimento caso haja alguma exceção na classe de negócio;
cleanVariables - libera os objetos instanciados para garbage collection executar a exclusão dos mesmos na memória.

Quando o VSet Chameleon recebe uma requisição para executar o processo, serão executadas as fases (métodos) na forma sequencial:

enhancementLayer
validate
beforeProcess
process
afterProcess
finalize

Se houver alguma exceção por parte da execução da classe de negócio, o VSet Chameleon executará o método rollback() para desfazer o contexto transacional.

O método process() é o principal método que executa as regras de negócio da classe de negócio.

Nota: Todas as classes de negócio deverão ser sempre herdadas ou derivadas da classe BusinessProcessWrapper.

Classe de Autenticação

Para aceitar qualquer requisição de processo pelo usuário no VSet Chameleon, é necessário que se tenha efetuado uma autenticação do usuário, senão a requisição será recusada.

Para se criar uma classe de autenticação, deverá ser herdada a classe AuthenticationProcessWrapper. Deverá ser implementado no método authenticate() o processo de autenticação do usuário. Após o sucesso da autenticação da classe, o VSet Chameleon criará uma instância de sessão a qual processará as requisições solicitadas pelo usuário autenticado.

Variável de Sessão

Toda requisição nova de um usuário novo no VSet Chameleon, é criada uma instância chamada de “sessão” para o usuário. A instância do usuário (sessão) permite obter e armazenar os valores pertinentes desse usuário. Toda sessão tem o seu tempo de vida de ociosidade. Uma vez expirado o tempo, o VSet Chameleon encerrará a sessão do usuário. O tempo de vida pode ser gerenciado por meio do parâmetro sessionLiveTime na seção listen do arquivo de configuração vsetchameleonConfig.xml em minutos.

Atenção: Caso queira que a sessão nunca seja expirada, o parâmetro sessionLiveTime deverá ser zero.

Nota: Caso algum processo uma informação que seja compartilhada com outro processo posterior na mesma instância do usuário, esta opção seria útil para armazenar a informação.

No VSet Chameleon para armazenar as informações e obtê-las na sessão, eis os métodos:

Método	Tipo	Descrição
`setSessionProperty(String key, Object value)`	void	Insere uma informação tipo objeto ou String
`setSessionPropertyInt(String key, int value)`	void	Insere uma informação tipo int
`setSessionPropertyLong(String key, long value)`	void	Insere uma informação tipo long
`setSessionPropertyByte(String key, byte value)`	void	Insere uma informação tipo byte
`setSessionPropertyDouble(String key, double value)`	void	Insere uma informação tipo Double
`setSessionPropertyBool(String key, boolean value)`	void	Insere uma informação tipo boolean
`getSessionProperty(String key)`	Object	Obtém uma informação tipo objeto
`getSessionProperty(String key)`	int	Obtém uma informação tipo int
`getSessionPropertyLong(String key)`	long	Obtém uma informação tipo long
`getSessionPropertyByte(String key)`	byte	Obtém uma informação tipo byte
`getSessionPropertyDouble(String key)`	double	Obtém uma informação tipo Double
`getSessionPropertyBool(String key)`	boolean	Obtém uma informação tipo boolean
`getSessionPropertyStr(String key)`	String	Obtém uma informação tipo String

Atenção: Para obter esses métodos, é necessário herdar pelo menos uma das classes BusinessProcessWrapper.

Exemplos:

Armazenando uma informação na sessão:

   // String
   SetProperty ("UserID", “12345”); 
   // int
   SetPropertyInt ("User", 12345); 

Recuperando uma informação da sessão:

   // String
   String user = getPropertyStr("UserID");
   // int
   int user = getPropertyInt("UserID");

Serviço

Algumas atividades ou tarefas precisam ser executadas na forma de processamento “batch”, ao contrário do processamento “online”. Para que as atividades ou tarefas sejam processadas na forma “batch”, o VSet Chameleon implementou uma base que permite executá-las sob “background” com controle de processamento, sendo denominada como serviço.

O VSet Chameleon tem o módulo de gerenciador de serviços que é responsável pelo ciclo de vida da execução do serviço, desde a sua criação até o término do processamento. Existem recursos para agendar, cancelar, postergar e antecipar o processamento e, ainda, disparar outros serviços por meio de eventos ou gatilhos (Trigger).

A implementação de regras de negócio da atividade ou tarefa é feita pela “classe de serviço” ou pelas classes da biblioteca de “classe negócio” do VSet Chameleon.

Classe de Serviço

Uma das bases de execução do processo de negócio do VSet é o serviço. É sempre executado na forma de background de acordo com os parâmetros definidos. Existem várias formas de inicializar o serviço: pelo agendamento, pelo disparo por evento, durante a criação da instância de serviço e na inicialização do VSet Chameleon.

O ciclo de vida do serviço é definido por parâmetro que pode ser uma única execução (one-shot), contínuo (periódico) pausada por um intervalo ou por agendamento.

A classe de serviço deverá herdar ou derivar da classe Service. Os seguintes métodos deverão ser implementados:

initialize – quando é criada a instância do serviço, o VSet Chameleon executará a implementação no método initialize;
recover - caso houver halt (parada) do servidor ou VSet Chameleon durante do processamento do serviço e ao iniciar o servidor ou VSet Chameleon, necessite de recuperar a uma parte que já foi executado;
process - onde executa a implementação da regra de negócio. Pode ser contínuo (periódico) ou única vez (one-shot);
finalize – quando termina o ciclo de vida do serviço, o VSet Chameleon executa a implementação no método finalize;
cleanVariables - excerto para liberar os objetos instanciados para garbage collection executar a exclusão dos mesmos na memória.

Propriedades/parâmetros da classe de serviço:

Propriedade/Parâmetro	Descrição
`setNameService(String nameService)`	Nome do serviço
`setDescription(String description)`	Descrição do serviço
`setObjectParams(Object params)`	Parâmetros para serviço
`setTimeWait(long timeWait)`	Tempo em milissegundos para pausa do modo de serviço interativo
`setStop(boolean stop)`	Parar o serviço - Encerrar a execução do serviço quando o modo do serviço é interação.

Atenção: Caso haja algum ato inesperado que inicializou o serviço VSet Chameleon ou queda do servidor, a classe de serviço deverá implementar uma rotina para recuperar o processamento no método recover, se houver necessidade.

Agendamento do Serviço

No VSet Chameleon existe um gerenciador de agendamento SchedulingManager, o qual é responsável por todo o mecanismo de agendamento do processo, tais como: iniciar, cancelar e registrar. Toda vez que é criado um agendamento de serviço no VSet Chameleon, é criado um ticket único de agendamento pelo gerenciador SchedulingManager.

Nota: É permitido agendar várias vezes a mesma classe de serviço. Para cada mesma classe de serviço criada (instância nova) ter-se-á o seu ticket único. Para saber quantos agendamentos existem da mesma classe de serviço, deve-se executar o método hasSchedulerByName, passando o parâmetro “nome do serviço” ou “nome da classe” e e será retornado quantos agendamentos existentes para mesma classe de serviço.

Existem quatro formas de agendar pelo gerenciador de agendamento SchedulingManager, por meio do método startTimeService, e sempre será retornado o ticket do agendamento:

startTimeService(Class<?> serviceClass, String date, String pattern, String description)

1 - serviceClass: nome da classe de serviço.
2 - date: data e/ou hora no formato Date que o serviço será processado.
3 - pattern: formato definido no parâmetro date.
4 - description: descrição sobre agendamento.

Exemplo:

   String ticket = SchedulingManager.startTimeService(MakeBackup.class, 
                                                      “02/08/2010 21:00”, 
                                                      “dd/MM/yyyy HH:mm”, 
                                                      “Rotina de backup de arquivos”);

startTimeService (Class<?> serviceClass, Date date, String description).
1 - serviceClass: nome da classe de serviço.
2 - date: data e/ou hora no formato Date que o serviço será processado.
3 - description: descrição sobre agendamento.

Exemplo:

   Date schedulerDate = new Date();
   String ticket = SchedulingManager.startTimeService(MakeBackup.class, 
                                                      schedulerDate, 
                                                      “Rotina de backup de arquivos”);

startTimeService (Class<?> serviceClass, Date date, Object params, String description)
1 - serviceClass: nome da classe de serviço.
2 - date: data e/ou hora no formato Date que o serviço será processado.
3 - params: parâmetros tipo objeto. São parâmetros específicos da classe de serviço que será executado.
4 - description: descrição sobre agendamento.

Exemplo:

   // 
   Date schedulerDate = new Date();
   Object parameter = new Parameter();
   String ticket = SchedulingManager.startTimeService(MakeBackup.class, 
                                                      schedulerDate, 
                                                      parameter,
                                                      “Rotina de backup de arquivos”);

startTimeService (String name, Class<?> serviceClass, Date date, Object params, String description)

1 - name: nome do serviço.
2 - serviceClass: nome da classe de serviço.
3 - date: data e/ou hora no formato Date que o serviço será processado.
4 - params: parâmetros tipo objeto. São parâmetros específicos da classe de serviço que será executado.
5 - description: descrição sobre agendamento.

Atenção: Quando passar o parâmetro “nome”, o mesmo deverá ser único. Como sugestão, além do nome incluir o nome da classe de serviço para garantir sua unicidade.

Exemplo:

   // 
   Date schedulerDate = new Date();
   Object parameter = new Parameter();
   String ticket = SchedulingManager.startTimeService("MakeBackup"
                                                      MakeBackup.class, 
                                                      schedulerDate, 
                                                      parameter,
                                                      “Rotina de backup de arquivos”);

Para executar o serviço imediatamente, utiliza-se o método startTimeServiceNow:

startTimeServiceNow (Class<?> serviceClass, Object params, String description)

1 - serviceClass: nome da classe de serviço.
2 - params: parâmetros tipo objeto. São parâmetros específicos da classe de serviço que será executado.
3 - description: descrição sobre agendamento.

Cancelamento do Agendamento

Para cancelar o agendamento, utiliza-se o método removeScheduler passando o parâmetro ticket do agendamento:

   SchedulingManager.removeScheduler(ticket);

Nota: Antes de fazer o cancelamento, utilize o método hasScheduler para verificar se o serviço ainda está agendado - SchedulingManager. hasScheduler(ticket);

Para cancelar todos os agendamentos existentes, utiliza-se o método removeAllScheduler.

Atenção: Recomenda-se utilizar esta opção em caso excepcional. Sugerimos sempre utilizar a opção, cancelamento individual removeScheduler para se ter mais controle.

Alteração do horário de Agendamento já existente

Para postergar ou antecipar a execução do serviço, utiliza-se o método changeTime e sempre será retornado o ticket do agendamento:

changeTime (String ticket, String date, String pattern);
1 - ticket: ticket agendamento.
2 - date: data e/ou hora no formato string que o serviço será processado.
3 - pattern: formato definido no parâmetro date.
changeTime (String ticket, Date date);
1 - ticket: ticket agendamento.
2 - date: data e/ou hora no formato Date que o serviço será processado.

Atenção: Qualquer alteração do horário da execução do serviço gerará novo ticket e o anterior será removido pelo VSet Chameleon.

Outros métodos úteis do gerenciador de agendamento

Método	Tipo	Descrição
`getTimeScheduler(String ticket)`	String	Recupera a informação do horário que foi agendada por meio do parâmetro ticket.
`getSchedulerList()`	ObjectTreeMap	Lista de todos os agendamentos existentes.

Disparo do serviço através de gatilho (Trigger)

O VSet Chameleon oferece a opção de disparar serviços através do gatilho (Trigger). Existem dois cenários para executar o gatilho (Trigger):

Cenário “orquestração” – o processo mestre orquestrará os disparos (trigger) nos processos participantes.
- Na forma “execução única (one-shot)”
  - Antes do processo de execução – antes do VSet Chameleon executar o processo principal da classe serviço.
    Forma sincrônica: o processo mestre disparará o processo participante (serviço) e aguardará a sua finalização com sucesso para seguir adiante de outro processo participante, se houver. Caso contrário, abortará a execução do serviço.
    Forma assincrônica: o processo mestre disparará o processo participante (serviço) e em seguida executará o próximo processo participante, se houver. O procedimento do processo mestre prossegue independentemente do resultado do processamento do processo participante.
  - Depois do processo de execução – depois do VSet Chameleon executar o processo principal da classe serviço.
    Forma sincrônica: o processo mestre disparará o processo participante (serviço) e aguardará a sua finalização com sucesso para seguir adiante de outro processo participante, se houver. Caso contrário, abortará a execução do serviço.
    Forma assincrônica: o processo mestre disparará o processo participante (serviço) e em seguida executará o próximo processo participante, se houver. O procedimento do processo mestre prossegue independentemente do resultado do processamento do processo participante e o processo mestre encerrará sua execução.
- Na forma “continua (periódica)”, pausada pelo intervalo
  Antes do processo de execução.
  Descrever ????
  Depois do processo de execução.
  Descrever ????
Cenário “coreografia”
Na forma execução única (one-shot).
Descrever ????
Na forma continua (periódica).
Descrever ????

Contexto Transacional

Contexto Transacional é o processo onde visa garantir a integridade de execução de tarefas ou atividades como todo. Se houver alguma falha durante a execução, será feita o processo de rollback.

VSet Chameleon implementou três nível de controle de contexto transacional. Eis os três níveis de controle transacional:

Nível Atômico: parte mais elementar onde uma atividade ou tarefa quando é executado com sucesso dentro de um contexto transacional será efetivada independentemente do resultado da execução do processo como todo.
Nível Bloco: garante o controle transacional das atividades ou tarefas executadas no escopo de bloco.
Nível Global: controle transacional da execução das atividades ou tarefas do processo como todo.

Biblioteca de Classes OO

Conforme dito anteriormente, o VSet Chameleon tem uma biblioteca de classes OO, com o objetivo de aumentar a produtividade e a qualidade do desenvolvimento de sistemas e também fazer os códigos de forma mais simples, com manutenibilidade.

São classes abstratas que permitem implementar as regras de negócio, abstraindo a parte de infraestrutura e controle, as quais ficam a cargo do VSet Chameleon.

São classes voltadas para a manipulação de dados por meio de banco de dados e arquivos, confecção de relatórios de vários formatos, conversão de tipos de mensagens diferentes.

Com base em necessidades de mudanças, sejam as evolutivas tecnológicas ou aperfeiçoamento de novos paradigmas, os desenvolvedores podem implementar novas classes para compor a Biblioteca de Classes OO do VSet Chameleon.

Banco de dados

Classe DAO (CRUD)

Para implementar uma classe de manipulação de dados no modelo CRUD com banco de dados, haverá a necessidade de herdar a classe CRUDDAOAbstract.

Sendo que possui o mesmo ciclo de execução da classe de negócio em fases (métodos) executado pelo VSet com intuito de oferecer flexibilização, organização e clareza para o desenvolvedor implementar suas regras de negócio.

Nota: Métodos são obrigados a serem declarados na classe de CRUD independentemente se serão utilizados ou não pela classe de CRUD.

Classe CRUDDAOWrapper
Classe CRUDDAOSQLWrapper

Classe DAO - SQL

Para implementar uma classe de manipulação de dados utilizando sintaxe SQL será necessário herdar a classe SQLDAOWrapper.

Classe DAO – Stored Procedure

Para implementar uma classe de manipulação de dados utilizando Stored Procedure haverá a necessidade de se herdar a classe StoredProcedureDAOAbstract.

Possui o mesmo ciclo de execução da classe de negócio em fases (métodos) executado pelo VSet com intuito de oferecer flexibilização, organização e clareza para o desenvolvedor implementar suas regras de negócio.

Modelo de uma classe SQL herdado da classe StoredProcedureDAOAbstract.

Arquivo

Para implementar uma classe de manipulação de dados em arquivo haverá a necessidade de herdar a classe FileWrapper ou FileDelimiterWrapper.

O arquivo poderá ter mais de um tipo de registro com layout diferente. Cada tipo de registro terá a sua classe.

Classe FileWrapper

Tem dois modos de manipulação de arquivo: leitura e gravação. O registro é lido ou gravado na forma posicional de acordo com a estrutura de dados do registro. O tamanho do campo varia de acordo com o tipo de arquivo: para o arquivo tipo binário, o tamanho será de acordo com o tipo do campo; para arquivo tipo texto, o tamanho será de acordo com especificação da propriedade de tamanho (size) do campo.

Classe FileDelimiterWrapper

Tem dois modos de manipulação de arquivo: leitura e gravação. O registro é lido ou gravado na forma de um delimitador de acordo com a estrutura de dados do registro.

Modelo​

Processo de negócio​

Classe de Negócio​

Classe de Autenticação​

Variável de Sessão​

Serviço​

Classe de Serviço​

Agendamento do Serviço​

Cancelamento do Agendamento​

Alteração do horário de Agendamento já existente​

Outros métodos úteis do gerenciador de agendamento​

Disparo do serviço através de gatilho (Trigger)​

Contexto Transacional​

Biblioteca de Classes OO​

Banco de dados​

Classe DAO (CRUD)​

Classe DAO - SQL​

Classe DAO – Stored Procedure​

Arquivo​

Classe FileWrapper​

Classe FileDelimiterWrapper​

Modelo

Processo de negócio

Classe de Negócio

Classe de Autenticação

Variável de Sessão

Serviço

Classe de Serviço

Agendamento do Serviço

Cancelamento do Agendamento

Alteração do horário de Agendamento já existente

Outros métodos úteis do gerenciador de agendamento

Disparo do serviço através de gatilho (Trigger)

Contexto Transacional

Biblioteca de Classes OO

Banco de dados

Classe DAO (CRUD)

Classe DAO - SQL

Classe DAO – Stored Procedure

Arquivo

Classe FileWrapper

Classe FileDelimiterWrapper