SISTEMA DE ENSINO PRESENCIAL CONECTADO

ESPECIALIZAÇÃO EM DESENVOLVIMENTO DE APLICAÇÕES

WEB BASEADAS NA TECNOLOGIA JAVA

RODRIGO OLIVEIRA PORTO

ELABORAÇÃO E DESENVOLVIMENTO DO SISTEMA DE

GESTÃO PENITENCIÁRIO – SISGESPEN PARA A
SECRETARIA ESTADUAL DE DEFESA SOCIAL DO
TOCANTINS

Palmas-TO
2013
 RODRIGO OLIVEIRA PORTO

ELABORAÇÃO E DESENVOLVIMENTO DO SISTEMA DE

GESTÃO PENITENCIÁRIO – SISGESPEN PARA A
SECRETARIA DE DEFESA SOCIAL DO TOCANTINS

Projeto apresentado à UNOPAR – Universidade Norte do

Paraná, através do Sistema de Ensino Presencial
Conectado, disciplina monografia, como requisito parcial
para obtenção do título de Especialista em
Desenvolvimento de Aplicações Web Baseadas na
Tecnologia Java.

Palmas-TO
2013
 DEDICATÓRIA

Dedico este primeiramente a Deus, pois, como disse o Apóstolo São Paulo:

“- Meu precioso filho, eu te amo, e jamais te deixaria nas horas

de tua prova e de teu sofrimento. Quando vistes na areia
apenas um par de pegadas, foi exatamente aí, que eu te
carreguei nos Braços.”

Em segundo a minha eterna namorada, esposa, amiga, companheira, e demais

adjetivos capazes de qualificá-la, que sempre incentivou e de certa forma teve muita
paciência no período de confecção deste. – Te amo Leidianny.

A minha filha Yasmin que a cada dia faz meus olhos brilhar com seu jeito simples
e sincero de expressar suas emoções e sentimentos. – Filha tenho muito orgulho de
você e te amo muito.

Aos meus pais Lourival e Ana que me ensinaram princípios aos quais não seria
possível aprender em nenhum outro lugar, que sempre deram forças e incentivos em
tudo que fiz, apesar de suas dificuldades. – Pai, mãe amo vocês.

A minha sogra, já que praticamente me adotou como terceiro filho. – Obrigado

Rosita, por tudo.

E, a todos aqueles que de uma forma ou de outra sempre acrescentam

experiência de vida a minha humilde pessoa.

(Rodrigo Oliveira Porto)

 SUMÁRIO
1 - INTRODUÇÃO.............................................................................................................................11
1.1 - Justificativa...............................................................................................................................13
1.2 - Objetivo Geral...........................................................................................................................14
1.2.1 - Objetivos Específicos.............................................................................................................15
1.3 - Escopo......................................................................................................................................16
1.4 – Estrutura do projeto................................................................................................................17
2 – SISTEMA PENITENCIÁRIO FEDERAL / ESTADUAL.........................................................................18
2.1 – Metodologias utilizadas...........................................................................................................18
2.2 – Contexto atual do sistema.......................................................................................................18
2.3 – O déficit de vagas no sistema e a superlotação.......................................................................19
2.4 – O Sistema Penitenciário e Prisional do Tocantins.....................................................................21
2.5 – Organização do Sistema Penitenciário e Prisional do Tocantins...............................................23
3 – TECNOLOGIAS UTILIZADAS NO DESENVOLVIMENTO DE SOFTWARE PARA WEB.........................24
3.1 – Linguagem Unificada de Modelagem – UML...........................................................................24
3.1.1 – Os Diagrama da UML............................................................................................................25
3.2 – Analise Orientado a Objeto......................................................................................................27
3.3 – Gerenciamento de Projetos de Software para web.................................................................31
3.4 – Sistema de Gerenciador de Banco de Dados – SGBD para Aplicações web.............................32
3.4.1 – Persistência de Dados em Java e a especificação JPA............................................................33
3.5 – Contêineres para aplicações web.............................................................................................36
3.6 – Linguagem de Programação Java para Web e o Padrão de Projeto MVC.................................37
3.6.1 – Padrão de Projeto Modelo Visão Controle (Model View Controller) - MVC..........................39
3.7 – Frameworks para desenvolvimento.........................................................................................41
3.7.1 – Java Server Faces – JSF..........................................................................................................41
3.7.2 – Hibernate..............................................................................................................................48
3.7.3 – Facelets.................................................................................................................................51
3.7.4 – Biblioteca de componentes - Primefaces..............................................................................53
4 – PROJETO: Sistema de Gestão Penitenciário - SISGESPEN............................................................57
4.1 – Introdução ao Problema..........................................................................................................57
4.2 – Estudo da Estrutura funcional da Secretaria de Defesa Social - SEDS......................................57
4.3 – Modelagem do Problema a ser resolvido................................................................................59
4.3.1 – Pesquisa para Obtenção dos Diagramas...............................................................................59
 4.3.2 – Diagramas de Caso de Uso - SISGEPEN.................................................................................59
4.3.3 – Diagramas de Classe - SISGEPEN...........................................................................................61
4.4 – Configurações para a persistência via JPA................................................................................63
4.5 – Modelos de dados...................................................................................................................63
4.6 – Telas do Projeto – SISGESPEN..................................................................................................63
5 – CONCLUSÃO...............................................................................................................................65
5.1 – Considerações Finais................................................................................................................65
5.2 – Trabalhos Futuros....................................................................................................................66
BIBLIOGRAFIA..................................................................................................................................67
APÊNDICES......................................................................................................................................69
A – Arquivo Persistence.xml.............................................................................................................69
B – Pacotes do sistema.....................................................................................................................70
C – Classe do pacote br.to.gov.JPAUtil.java.......................................................................................71
D – Classe do pacote br.to.gov.modelo.Advogado.java.....................................................................72
E – Classe do pacote br.to.gov.modelo.Agente.java..........................................................................73
F – Classe do pacote br.to.gov.modelo.Cela.java..............................................................................74
G – Classe do pacote br.to.gov.modelo.Interno.java.........................................................................75
H – Outras classe do pacote br.to.gov.modelo..................................................................................77
H – InterfaceDAO.java pacote br.to.gov.DAO....................................................................................78
J – Classe DAO Genérico pacote e classe br.to.gov.DAO.classe.........................................................79
K – Classe DAO especifico para Internos pacote br.to.gov.DAO classe InternoDAO.java...................80
L – Classe DAO especifico para Unidade Prisional pacote br.to.gov.DAO classe
UnidadePrisionalDAO.java................................................................................................................82
M – Classe DAO especifico para Agente pacote br.to.gov.DAO classe AgenteDAO.java....................83
N – Demais classes do pacote br.to.gov.DAO....................................................................................85
O – EntityConverter.java esta no pacote br.to.gov.conversor............................................................86
P – Classes do pacote br.to.gov.beans - AdvogadoBean.java...........................................................88
Q – Classes do pacote br.to.gov.beans - InternoBean.java...............................................................90
R – Demais classes do pacote br.to.gov.beans..................................................................................92
S – Arquivos xhtml............................................................................................................................93
T – Arquivos xhtml para cadastro de Agentes...................................................................................94
U – Arquivos xhtml para listagem de Internos..................................................................................96
V – Arquivos xhtml para consultas de Internos.................................................................................98
W – Arquivos xhtml para os menus..................................................................................................99
X – Arquivos xhtml para o templade...............................................................................................101
Y – Tela de cadastro dos Agentes....................................................................................................102
Z – Tela de cadastro dos Internos...................................................................................................103
AA – Tela de cadastro Unidade Prisional........................................................................................104
AB – Tela de consulta de Agentes...................................................................................................105
AC – Tela de consulta de Internos...................................................................................................106
AD – Tela de listagem de Agentes...................................................................................................107
AE – Tela de listagem de Internos Dados Pessoais e Socioeconomicos...........................................108
AF – Tela de listagem de Advogados...............................................................................................109
AG – Tela de alteração de Advogados.............................................................................................110
 TABELAS
Tabela 1 – Analise da situação prisional do Estado Fonte: Elaborado pelo autor.................................22
Tabela 2 – Tipos de diagramas da UML versão 2.0 conforme (MELO, 2004).........................................26
Tabela 3 – Implementações JSF Fonte: Elaborado pelo autor...............................................................41
Tabela 4 – Componentes do grupo Core do JSF Fonte: Adaptado pelo autor.......................................43
Tabela 5 – Componentes do grupo HTML do JSF Fonte: Adaptado pelo autor.....................................43
Tabela 6 – Lista arquivos da configuração Hibernate e JPA Fonte: Adaptado pelo autor......................48
Tabela 7 – Componentes do Primefaces Fonte: Adaptado pelo autor..................................................54
Tabela 8 – Características do SISGESPEN Fonte: Autor.........................................................................56
Tabela 9 – Caso de Uso Manter Unidades Fonte: Autor.......................................................................59
 ILUSTRAÇÕES
Ilustração 1 – Ilustração do funcionamento do sistema prisional atual Fonte: Adaptado pelo autor...21
Ilustração 2 – Organograma do Sistema Prisional do Tocantins e suas atribuições Fonte: Adaptado
pelo autor.............................................................................................................................................24
Ilustração 3 – Mensagens entre objetos Fonte: www.metropoledigital.ufrn.br...................................29
Ilustração 4 – Representação de uma classe através da UML Fonte: www.guiadophp.yoonix.com.br. 30
Ilustração 5 – Representação de herança através da UML Fonte: www.usandoaccess.com.br............30
Ilustração 6 – Representação de polimorfismo Fonte: www.eufacoprogramas.com............................31
Ilustração 7 – Representação de generalização Fonte: www.microsoft.com........................................31
Ilustração 8 – Representação das partes do gerenciamento de projetos web Fonte:
http://ainternetenossa.wordpress.com................................................................................................33
Ilustração 9 – Representação SGDB Relacional Fonte: http://www.macoratti.net...............................34
Ilustração 10 – Funcionamento do Mapeamento Objeto Relacional Fonte:
http://www.devmedia.com.br.............................................................................................................35
Ilustração 11 – Funcionamento do JPA(Provider Hibernate) Fonte: http://www.theopentutorials.com
.............................................................................................................................................................37
Ilustração 12 – Visão geral do framework JSF Fonte: wwwespecializa.com.br.....................................39
Ilustração 13 – Visão geral da Evolução do Java para web Fonte: wwwespecializa.com.br..................40
Ilustração 14 – Arquitetura JSF Fonte: wwwespecializa.com.br..........................................................40
Ilustração 15 – Exemplo padrão MVC Fonte: www.klebermota.eti.br..................................................41
Ilustração 16 – Exemplo pagina usando JSF Fonte: Autor.....................................................................46
</html>.................................................................................................................................................46
Ilustração 17 – Ciclo de vida pagina JSF Fonte: victorsato.com............................................................48
Ilustração 18 – Ciclo de vida pagina JSF visão do processamento Fonte: http://osl2.uca.es................48
Ilustração 19 – Exemplo de configuração arquivo Hibernate.cfg.xml Fonte: http://tech-
gcs.blogspot.com..................................................................................................................................51
Ilustração 20 – Exemplo de configuração arquivo persistence.xml.......................................................51
Fonte: http://blog.camilolopes.com.br................................................................................................51
Ilustração 21 – Definição de um arquivo de estilo Fonte: Autor...........................................................53
Ilustração 22 – Definição de um Tamplate em Facelets Fonte: Autor...................................................53
Ilustração 23 – Definição de arquivo usando o template anterior Fonte: Autor...................................54
Ilustração 24 – Organograma Secretaria da Defesa Social – SEDS (Ex-Secretaria da Justiça e dos
Direitos Humanos) Fonte: Autor...........................................................................................................59
Ilustração 25 – Diagrama de Caso de Uso Fonte: Autor.......................................................................61
Ilustração 26 – Diagrama de Classe Fonte: Autor.................................................................................63
Ilustração 27 – Tela de login do SISGESPEN Fonte: Autor.....................................................................64
Ilustração 28 – Tela principal do SISGESPEN Fonte: Autor....................................................................65
Ilustração 29 – Tela de cadastro dos Agente no SISGESPEN Fonte: Autor...........................................103
Ilustração 30 – Tela de cadastro dos Internos no SISGESPEN Fonte: Autor.........................................104
Ilustração 31 – Tela de cadastro das Unidades Prisionais no SISGESPEN Fonte: Autor.......................105
Ilustração 32 – Tela de consulta de Agentes no SISGESPEN Fonte: Autor...........................................106
Ilustração 33 – Tela de consulta de Internos no SISGESPEN Fonte: Autor...........................................107
Ilustração 34 – Tela de listagem de Agentes SISGESPEN Fonte: Autor................................................108
Ilustração 35 – Tela de listagem de Internos SISGESPEN Fonte: Autor................................................109
Ilustração 36 – Tela de listagem de Advogados SISGESPEN Fonte: Autor...........................................110
Ilustração 37 – Tela de alteração de Advogados SISGESPEN Fonte: Autor..........................................111
 FOTOS
Foto 1 – Contagem (MG) Fonte: Câmera dos Deputados – CPI Sistema Carcerário............19
1 - INTRODUÇÃO

Dados do Ministério da Justiça através do Departamento Penitenciário

Nacional – DEPEN, mostram que nos últimos 8(oito) anos a população carcerária do
Brasil saltou de 361.402 presos em 2005 para 548.003 presos em 2012, um
aumento de 51,63%. Ainda, segundo o mesmo órgão desta vez com dados de 2008,
mostra que há estados da federação em que para cada 100.000 habitantes, 545
estão atrás das grades e destes 74% está na faixa etária entre 18 e 34 anos, ou
seja, na fase da vida em que mais poderiam contribuir com o desenvolvimento de
suas próprias famílias e do Brasil.
Neste mesmo contexto (Santos, 2012), afirma que o “encarceramento
continuará a crescer no sistema penitenciário brasileiro, já que a porta de entrada é
muito superior a de saída”. Já (Julião, 2009) destaca que o “Brasil é o terceiro maior
encarcerado do mundo” e que o “sistema brasileiro tem sido tratado
predominantemente sob a estreita lógica do confinamento de pessoas”. O autor vai
além informando que:
O sistema penitenciário assenta-se sobre a punição como forma real e
simbólica de solução do problema, propondo, em tese, a ressocialização
dos detentos, supondo que o “desrespeito” às normas esteja relacionado a
uma falta de disciplina moral para o convívio em sociedade.

Na contramão das informações apresentadas acima, ficam as perguntas

como o Brasil poderá minimizar o cárcere de sua mão de obra, ou melhor, como
ressocializar quem já está no sistema?
Para (Julião, 2009) “o problema está na forma como as políticas e práticas de
ensino e trabalho estão sendo executadas”, para ele a administração pública não
pode simplesmente manter o preso ocupado deve oferecer “trabalho formativo não
meramente ocupacional”. Para justificar os argumentos acima o autor após pesquisa
com mais de 50.000 presos apresenta que:
“A chance de um preso não reincidir no sistema após ter estudado dentro do
presídio é de 39%, caso ele aprenda uma profissão que lhe possibilite
exercê-la com menos contato com o público essa chance de não voltar ao
sistema aumenta para 48%.”

12
 Para que a administração pública possa oferecer o ensino e a capacitação da
forma como os pesquisadores vêm apontando para realizar uma efetiva
ressocialização dos presos, necessitará de uma ferramenta que possibilite primeiro
conhecer quem são, onde estão, quais as características e necessidades de cada
indivíduo.
Desta forma este trabalho visa desenvolver a priori um levantamento para
saber quais são as características do sistema prisional no estado do Tocantins e em
segundo momento uma ferramenta que possibilitará manter dados socioeconômicos
que servirão de base para a cúpula de políticas prisionais do estado a fim de
maximizar o esforço da ressocialização1 no estado.

1 Ressocialização significa reintegral uma pessoa novamente ao convívio social por meio de políticas
públicas que gere resultados duradores na vida do individuo evitando o reingresso no sistema.
13
1.1 - Justificativa

O Estado do Tocantins foi criado com a constituição de 1988, sendo assim, é

o mais jovem estado da federação, mas isto não impediu que o índice de
encarceramento não aumentasse como nos demais estados, dados mostram que
em 2005 existiam no estado 404 presos, agora em 2012 esse número saltou para
2.518 presos, esse resultado só não é mais grave porque neste mesmo período a
população do estado de acordo com IBGE 2 também cresceu de 1.157.098
habitantes em 2000 para 1.417.694 habitantes em 2012. Outro índice preocupante é
que segundo (Bento, 2010) no estado 75,6% dos presos não tem atividades.
Desta forma a ferramenta servira de base para o mapeamento dos presos,
seu grau de instrução e qualificações para assim definir os rumos da ressocialização
no estado. Cabe ressaltar que o Estado é carente de industriais aumentando ainda
mais o reingresso no sistema.

1.2 - Objetivo Geral

2 IBGE – Instituto Brasileiro de Geografia e Estatística

14
 Este trabalho se propõe a oferecer ao Estado do Tocantins subsídios para a
gestão da ressocialização de presos através de uma ferramenta de gestão e
controle que possibilitará o acompanhamento da vida do preso desde sua entrada
no sistema até a sua reintegração à sociedade de forma que se possa identificar
invidualmente qual a melhor alternativa para cada preso do sistema.
O principal resultado esperado ao final do trabalho é municiar a administração
penitenciária de ressocialização de informações que possam recuperar o preso
evitado assim o seu reingresso no sistema.

15
1.2.1 - Objetivos Específicos

Permitir que a administração estadual obtenha um raio x das pessoas que

estão presas hoje dentro do sistema penitenciário, podendo dele definir sua política
de ressocialização;
Gerar qualidade de vida ao preso possibilitando sua reintegração social e
principalmente ao mercado de trabalho;
Melhorar a comunicação entre a gestão de ressocialização e os gestores dos
estabelecimentos prisionais;
Obter e trocar informações dentro sistema prisional de forma rápida e
eficiente;
Mostrar a sociedade através de dados que um preso não pode simplesmente
ser esquecido dentro do sistema, ele precisa principalmente de apoio para que
possa voltar ao convívio social.

16
1.3 - Escopo

Este trabalho tem como produto um software que possibilitará obter

informações detalhadas dos presos dentro do sistema prisional do Tocantins.
Para melhor entendimento e utilização da ferramenta está foi dividida em
partes, a saber:
 Registro de Unidades  Visa o registro de todas as unidades
classificadas por tipo, onde há guarda de presos;
 Registro de agentes  Consiste no registro dos agentes que realizam
a tutela dos presos;
 Registro de Advogados  Consiste no cadastro único de advogados
que executa assistência dos presos no estado;
 Registro de Internos  Visa o preenchimento de informações relevante
sobre os internos (presos), tais como, dados pessoais,
socioeconômicos e outros que possam ajudar na ressocialização;
 Registro da Assistência Educacional do preso  Visa manter
informações de quais indivíduos possui quais cursos;
 Registro de Visitantes  Consiste no registro de pessoas que mantém
contato com os presos dentro do sistema e qual sua influencia positiva
ou negativa para a sua ressocialização.

17
1.4 – Estrutura do projeto

Este trabalho foi subdividido em 5(cinco) áreas denominadas de capítulos.

No capitulo 1, temos a introdução que define o contexto e objetivos gerais e
específicos do trabalho.
No capitulo 2 detalhamos algumas informações sobre o sistema penitenciário
brasileiro e tocantinense bem como alguns fatores históricos e além é claro da
metodologia adotada para este trabalho..
No capitulo 3, descrevemos as tecnologias utilizadas na atualidade para o
desenvolvimento de softwares corporativos web.
No capitulo 4, apresentamos o produto do trabalho, ou seja, o software
desenvolvido durante a pesquisa para a solução do problema levantado, suas
principais funcionalidades serão descritas neste tópico.
No capitulo 5, abordamos a conclusão da pesquisa, quais as dificuldades
encontradas, sugestões de trabalhos futuros e considerações finais.

18
2 – SISTEMA PENITENCIÁRIO FEDERAL / ESTADUAL

2.1 – Metodologias utilizadas

Foi utilizada para elaboração deste trabalho uma pesquisa bibliografia e

documental que balizou os estudos e argumentos aqui apresentados. Grande parte
dos dados foi abstraída do portal de informações do Ministério da Justiça, os demais
vieram de livros especializados, revistas, pesquisas na internet e reportagens da
mídia em geral.
Tendo em vista que nossa analise será baseada a partir de literatura já
publicada, trata-se de um método de investigação cientifica indutiva.
Durante a pesquisa observamos que na atualidade devidas às pressões
externas os governos tentam resolver os problemas do setor, porém, há uma
discrepância em relação ao que é executado é o que é defendido pelos especialistas
em ressocialização.

2.2 – Contexto atual do sistema

O sistema penitenciário brasileiro vive momentos de turbulências causadas

pelas várias noticias sobre a real situação dos presos e estabelecimentos prisionais
do país. De um lado está a mídia e não somente a televisiva, mas em todos os
canais de comunicação, acompanhado dela está à sociedade que cobra ações mais
efetivas dos governos para combater o crime organizado e também entrou no
discurso o legislativo através de CPIs3.
Parte deste bombardeiro de fatos jogados no ventilador é culpa do próprio
sistema e dos governos, pois há tempos o sistema penitenciário vem dando sinais
de graves problemas, a outra parcela é da sociedade que apesar de pedir proteção
e segurança não contribui em nada com a ressocialização dos ex-presidiários, pelo
contrário os jogam a mercê da vida social obrigando-os a novamente voltar ao
sistema. Claro que não podemos generalizar, já que há casos isolados de resgate da
cidadania que tem funcionado e bem.
O problema como já mencionado no texto é que quem comete um crime e cai
no sistema têm enormes chances de voltar, deixando os estabelecimentos lotados.
Autores como (Viana, 2012) argumentam que “um dos fatores causador da
3 CPI  Comissão Parlamentar de Inquérito, formada para conduzir uma investigação através dos fatos e
apurações pelos parlamentares do Poder Legislativo.
19
superlotação é o descumprimento aos direitos do preso que são elencados pela Lei
7.210 de 1984, a Lei de Execuções Penais”. Por outro lado no Relatório Anual do
Centro de Justiça Global dos Direitos Humanos no Brasil 2003, (Carvalho, 2003)
afirma que:
A Lei de Execução Penal (LEP) brasileira é elogiada em todo o mundo, e
representa um dos maiores avanços jurídicos de nossa história. O grande
desafio das entidades da sociedade civil que atuam nesta área, sempre foi o
de reduzir a distância entre o arcabouço legal e o panorama real do sistema
penitenciário.

Desta forma, concluímos por indução que a questão legal está resolvida, ou
seja, não falta legislação para tratar do problema, o que precisa é colocar em prática
políticas que conduzam a ressocialição dos indivíduos hoje presos para por fim
conduzi-os novamente a sociedade de forma definitiva.

2.3 – O déficit de vagas no sistema e a superlotação

Para piorar o problema do sistema penitenciário um relatório de 2008,

elaborado pela CPI do sistema carcerário mostrou conforme (Viana apud Alves,
2008) que:
O déficit de vagas nas penitenciárias brasileiras tem aumentado cada vez
mais, em 2005 de acordo com os dados apresentados pelo departamento
penitenciário nacional existia a falta de 135 mil vagas, recentemente o
relatório da CPI do sistema carcerário apresentado em junho de 2008
mostra um aumento superior a 30%. O relator desta Comissão Parlamentar
de Inquérito, o deputado Domingos Dutra, “estima que seriam necessárias,
hoje, 180 mil vagas para que não houvesse superlotação nos presídios
brasileiros, o sistema que tem capacidade para 260 mil detentos, abriga
mais de 440 mil”.

Mais uma vez por dedução podemos afirma que, se o sistema não consegue
recuperar quem já está dentro e considerando que novos presos entram todos os
dias, a situação é no mínimo preocupante. Outro dado que merece destaque é
conforme afirma (Viana, 2012), a “questão dos presos que já cumpriram sua pena, e
não são postos em liberdade, bem como, o grande número de presos provisórios
que estão nos presídios juntamente com os sentenciados”. Na foto 1, podemos
perceber a gravidade do problema e na ilustração 1 observaremos como o sistema
está funcionando na atualidade.

20
Foto 1 – Contagem (MG) Fonte: Câmera dos Deputados – CPI Sistema Carcerário

Ilustração 1 – Ilustração do funcionamento do sistema prisional atual Fonte: Adaptado pelo autor

21
2.4 – O Sistema Penitenciário e Prisional do Tocantins

No Tocantins segundo dados publicado pela Secretaria de Defesa Social que

é a atual responsável pela guarda e custodias dos presos, bem como coordenadora
das políticas de ressocialização estadual, existe hoje a seguinte situação.

Gráfico 1 – Comparativo entre regimes Fonte: www.defesasocial.to.gov.br

Gráfico 2 – Presos Provisórios por região Fonte: www.defesasocial.to.gov.br

22
Gráfico 3 – Presos Semiabertos por região Fonte: www.defesasocial.to.gov.br

Gráfico 4 – Presos Fechados por região Fonte: www.defesasocial.to.gov.br

Após analise dos dados podemos constatar a seguinte situação:

Regime
Sul
Representa a menor parcela
de presos entre as regiões,
mas necessitarão de
Provisórios políticas para incluir esses
290 presos no mercado de
trabalho em médio prazo.
Semiabertos Onde as políticas de
reintegração social precisam
ser colocadas em prática
Região
Central
Segunda menor
concentração de presos
entre as regiões, porém o
número de presos que
deverão retornar a
sociedade é de 353, isto
em médio prazo.
Aqui também há um
grande número de presos
neste regime, são 105
Norte
Contém a maior
concentração de presos
provisórios do estado,
necessitando de 537
recolocações na
sociedade em médio
prazo.
Apesar de representar
apenas 23% dos presos
em semiliberdade essa
23
 com urgência, já que têm
169 presos somente
dormindo no sistema,
necessitam de respostas no
curto prazo.
Região com muitos presos
fechados são 413 no total,
considerando que a maioria
passará mais tempo na
Fechados prisão as políticas devem ser
pensadas para longo prazo.
Tabela 1 – Analise da situação prisional do Estado Fonte: Elaborado pelo autor
somente dormindo no região necessita
sistema, as políticas reintegrar 83 presos no
necessitam de respostas curto prazo
no curto prazo.
Região com menos Região também com
presos fechados, mas muitos presos fechados
mesmo assim um são 423 no total,
quantitativo considerando que a
representativo para o maioria passará mais
estado são 248 presos tempo na prisão as
que precisaram ser políticas devem ser
trabalhados em longo pensadas para longo
prazo. prazo.

2.5 – Organização do Sistema Penitenciário e Prisional do Tocantins

Para gerir o sistema penitenciário o órgão gestor é composto pelas seguintes

unidades administrativas:

Ilustração 2 – Organograma do Sistema Prisional do Tocantins e suas atribuições Fonte: Adaptado

pelo autor

24
3 – TECNOLOGIAS UTILIZADAS NO DESENVOLVIMENTO DE
SOFTWARE PARA WEB

3.1 – Linguagem Unificada de Modelagem – UML

À medida que os softwares ganharam maior importância na gestão das

empresas tornando-se cada vez mais necessários e complexos, houve também a
necessidade de estabelecimento de regras para produção destes. Foi assim que em
1996, Grady Booch, James Rumbaugh e Ivar Jacobson propuseram um conjunto de
técnicas que receberam o nome de UML 0.9, antes deste padrão cada
desenvolvedor buscava utilizar seus próprios critérios de desenvolvimento. O que
segundo (BOOCH, RUMBAUGH e JACOBSON, 2005), ficou conhecido como
“guerra de métodos”.
O padrão proposto pelos três autores derivava das experiências que cada um
tinha em seus métodos de modelagem de sistemas, já que o método conhecido por
OOSE (Object-Oriented Software Engineering) focado principalmente em casos de
uso pertencia a Jacobson, o modelo OMT (Object Modeling Technique) que era
respeitado por seu desempenho na fase de análise de sistemas de informação era
de Rumbaugh e por ultimo o modelo Booch que se destacava na fase de projetos e
que pertencia ao autor de mesmo nome. Ao selarem essa união os autores
estabeleceram três objetivos para o projeto:
1. Fazer modelagem de sistemas, do conceito ao artefato executável, com a
utilização de técnicas orientadas a objetos
2. Incluir questões de escala, inerentes a sistemas complexos e de tarefas
críticas.
3. Criar uma linguagem de modelagem a ser utilizada por seres humanos e por
máquinas (BOOCH, RUMBAUGH e JACOBSON, 2005).

O fato é que com a união destes três metodistas a orientação a objeto ganhou
ainda mais força dentro do universo de desenvolvimento de software, pois, a UML
proporcionou uma maneira mais adequada de comunicação entre os
desenvolvedores e os clientes. A autora (MELO, 2004), argumenta que “é essa
facilidade de entendimento e absorção de ideias, não só pelo desenvolvedor, mas
também e principalmente pelo usuário, que faz com que a UML seja cada vez mais
adotada”.
Para (MELO, 2004), a UML:
25
 Auxilia na construção de software, pois permite um mapeamento de seus
modelos para as linguagens de programação, ou vise versa. Assim, é
possível gerar código a partir de modelos da UML, ou com um suporte
adequado realizar a engenharia reversa, reconstruindo um modelo a partir
de sua implementação.

Facilita a documentação, pois possui suporte para a criação e

documentação de vários dos artefatos que são gerados durante o
desenvolvimento de um sistema, como: requisitos, arquitetura, projeto,
código-fonte, planos de projeto, testes, protótipos e versões.

3.1.1 – Os Diagrama da UML

Com a aprovação da UML versão 2.0, treze tipos de diagramas foram

especificados sendo eles de dois tipos conforme (MELO, 2004), descreve em sua
obra, os “diagramas estruturais” e os “diagramas dinâmicos”, o primeiro tem a
função de “mostrar as características do seu sistema que não mudam com o tempo”,
já o segundo “mostram como o sistema responde às requisições ou como o mesmo
evolui durante o tempo”. Na tabela 3 é apresentado segundo (MELO, 2004) as
características principais de cada um dos diagramas.
Diagramas Apresenta elementos conectados por
Estruturais relacionamentos. Usados para exibir
Diagrama de Classes
entidades do mundo real, além de
elementos de análise e projeto.
Apresenta objetos e valores de dados.
Corresponde a uma instância do
Diagrama de Objetos diagrama de classes, mostrando o
estado de um sistema em determinado
ponto do tempo.
Mostra as dependências entre
Diagrama de
componentes de software,
Componentes
apresentando suas interfaces.
Diagrama de Mostra a arquitetura do sistema em
Implantação tempo de execução, as plataformas de
hardware, artefatos de software e

26
 ambientes de software (como sistemas
operacionais e máquinas virtuais)
Usado para organizar elementos de
Diagrama de Pacotes modelo e mostrar dependências entre
eles.
Usado para mostrar a composição de
uma estrutura. Útil em estruturas
Diagrama de Estrutura
compostas de estruturas complexas ou
Composta
em projetos baseados em
componentes.
Mostra os casos de uso, atores e seus
Diagrama de Caso de
relacionamentos que expressam a
Uso
Diagramas funcionalidade de um sistema.
Diagramas de Interação
Dinâmicos
Uma variação do diagrama de
atividades que mostra de uma forma
geral o fluxo de controle dentro de um
Diagrama de Visão Geral sistema ou processo de negócios. Cada
nó ou atividade dentro do diagrama
pode representar outro diagrama de
interação.
Mostra as interações que correspondem
a um conjunto de mensagens trocadas
Diagrama de Sequencia
entre objetos e a ordem que essas
mensagens acontecem.
Mostra a mudança de estado de
Diagrama Temporal um objeto numa passagem de tempo,
em resposta a eventos externos.
É o antigo diagrama de colaboração,
Diagrama de que mostra objetos, seus inter-
Comunicação relacionamentos e fluxo de mensagens
entre eles.
Diagrama de Atividade Representa a execução de ações ou
atividades e os fluxos que são
disparados pela conclusão de outras
ações ou atividades.

27
 Diagrama de Máquina de Representa as ações ocorridas em
Estado resposta ao recebimento de eventos.
Tabela 2 – Tipos de diagramas da UML versão 2.0 conforme (MELO, 2004).

3.2 – Analise Orientado a Objeto

O termo analise orientado a objeto tem seu significado prático repensar a

forma como modelamos e projetamos softwares, onde estes compram com algumas
características que um bom produto orientado deve possuir. Para (Page-Jones,
2001) os principais atributos deste tipo de projeto são:
Encapsulamento  é o agrupamento de ideias afins em uma unidade.
Sendo assim um conjunto de operações e atributos o qual representa o
estado em um tipo de objeto, de tal forma que o estado é acessível ou
modificado somente pela interface provida pelo encapsulamento.

O encapsulamento de um objeto tem como uma de suas finalidades a de

proteger o objeto ao qual ele faz parte, pelas palavras de (Page-Jones, 2001), ele
forma uma espécie de “anel protetor”.
Outra característica de um projeto de software orientado a objeto é a:
Ocultação de informações e implementações  é a utilização de
encapsulamento para restringir a visibilidade externa de certos detalhes de
informações ou implementações, os quais são internos à estrutura de
encapsulamento.

Com a característica acima não importa como o objeto realiza suas

operações, ele retorna os dados e estados solicitados de acordo com o que foi
projetado através das suas interfaces públicas. As duas características apresentadas
até o momento são análogas a seguinte situação: Para o motorista de um veículo
não importa como o sistema de freios foram projetados e implementos, para ele o
importante é que quando ao acionar o pedal o carro diminua a velocidade.
O terceiro predicado de um software orientado é a “capacidade de um
objeto de reter seu estado”. Este conceito está relacionado à habilidade de
memória de um objeto, desde sua instanciação até o momento de destruição ele
sempre controlará seus estados internos, sabendo como está cada um deles.
O quarto conceitos de um projeto orientado a objeto é a identidade de
objeto, ela está relacionada à capacidade que um objeto tem de ser inconfundível,
ou seja, não importa quantos objetos há em um sistema todos são únicos dentro do
software. O autor já mencionado acima há descreve da seguinte forma.

28
 A identidade de objeto  é a propriedade pela qual cada objeto
(independentemente de sua classe ou seu estado) pode ser identificado e
tratado como uma entidade distinta de software.

A quinta propriedade é a mensagem, ela fornece um meio de um objeto

solicitar que outro objeto realize alguma informação para ele. Nas palavras de
(Page-Jones, 2001) ele a descreve da seguinte maneira:
Mensagem  Uma mensagem é o veículo pelo qual um objeto remetente
obj1 transmite a um objeto destinatário obj2 um pedido para o obj2 aplicar
um de seus métodos.

Abaixo podemos observar através da ilustração 3 um pouco mais desta

propriedade.

Ilustração 3 – Mensagens entre objetos Fonte: www.metropoledigital.ufrn.br

Nossa próxima qualidade a ser observada é a classe, talvez uma das mais
conhecidas do mundo dos objetos, a classe é nada mais que uma forma geradora
de objetos, sendo todos iguais, do ponto de vista dos atributos e métodos, mas,
únicos como objetos. Na ilustração 4 temos exemplos de classes representadas
através da UML. A primeira delas é a classe cachorro, através dela podemos ter
vários cachorros com nomes até iguais, mas, animais distintos, peso, cor do pelo,
bem como a forma de latir, abanar o rabo etc.

29
Ilustração 4 – Representação de uma classe através da UML Fonte: www.guiadophp.yoonix.com.br

Nossa próxima característica a ser estudada é a herança, ela é o que o

próprio nome já diz. Na vida real podemos dizer que um filho tem os olhos do pai, ou
seja, estamos dizendo que ele herdou do pai talvez a cor o formato e outras
propriedades dos olhos. Já no mundo orientado a objeto a herança representa a
capacidade de uma classe mais especifica herdar atributos e operações de outra
mais genérica assim podemos ter, por exemplo, uma classe genérica figura e outra
chamada quadrado. Desta forma, quadrado herda de figura o fato de também ser
uma figura, mas ele tem outras informações a mais.
Na ilustração 5 podemos visualizar melhor o conceito.

Ilustração 5 – Representação de herança através da UML Fonte: www.usandoaccess.com.br

A característica que analisaremos agora tem a capacidade de executar em

tempo de execução do software, estamos falando do polimorfismo que significa
muitas formas. Essa habilidade nos permite construir softwares altamente robustos e

30
ao mesmo tempo manuteníveis, já que reduz a quantidade de código produzido.
Como ilustração poderíamos novamente usar a de número 3 do exemplo sobre
mensagem, mas para reforça a ideia veja a ilustração 6.

Ilustração 6 – Representação de polimorfismo Fonte: www.eufacoprogramas.com

Nossa ultima característica a ser estuda é a generalização utilizada para que

uma classe fique altamente reaproveitável, pois carrega consigo uma capacidade
abstrata de só conhecer as classes que executar na hora da execução. Na listagem
7 temos um exemplo, observe que ela trabalho no sentido inverso ao da herança.

Ilustração 7 – Representação de generalização Fonte: www.microsoft.com

31
3.3 – Gerenciamento de Projetos de Software para web

A definição para gerenciamento de projetos pode ser abstraída do guia de

melhores praticas em gerenciamento de projetos (PMBOOK, 2008) que a descreve
da seguinte forma.
É um esforço temporário empreendido para criar um produto, serviço ou
resultado exclusivo. A sua natureza temporária indica um início e um término
definidos. O término é alcançado quando os objetivos tiverem sido atingidos
ou quando se concluir que esses objetivos não serão ou não poderão ser
atingidos e o projeto for encerrado, ou quando o mesmo não for mais
necessário.

Já o gerenciamento de projetos de software para web começa com a analise

do problema a ser resolvido, partido em seguida para a definição do objetivo a ser
almejado, o terceiro passo é conhecer e mapear o máximo de particularidades do
problema cabe ressaltar que dependendo do projeto primeiro é necessário mapear
as particularidades e depois definir o objetivo, a próxima etapa é decompor o
objetivo principal em partes menores e mais fáceis de serem trabalhadas ficando
assim mais gerenciáveis. Para (VALERIANO, 2009);
Para definir as atividades é importante que o Objetivo e o Produto estejam
bem definidos, o que significa que as pessoas envolvidas já sabem onde e
quando começa (tempo); que o final desejado (escopo) esteja claro. Como
vimos também, algumas Metas estejam estabelecidas, estas que são as
subdivisões com objetivos intermediários que são parciais até alcançar o
objetivo do projeto.

Esquematicamente o gerenciamento de projetos web pode ser representado

através da ilustração 8.

32
Ilustração 8 – Representação das partes do gerenciamento de projetos web Fonte:
http://ainternetenossa.wordpress.com

3.4 – Sistema de Gerenciador de Banco de Dados – SGBD para Aplicações web

Segundo (MAKRON), “um Sistema Gerenciador de Banco de Dados - SGBD

é constituído de dados associados a um conjunto de programas para acesso a
esses dados. O conjunto de dados, comumente chamado banco de dados, contém
informações sobre uma empresa em particular.”.
O objetivo de um SGBD é o de proporcionar recuperação e armazenamento
de forma segura e eficiente.
O gerenciamento de informações implica a definição das estruturas
de armazenamento das informações e a definição dos mecanismos para
manipulação dessas informações. Ainda, um sistema de banco de dados
deve garantir a segurança das informações armazenadas contra eventuais
problemas com o sistema, além de impedir tentativas de acesso não
autorizadas. Se os dados são compartilhados por diversos usuários, o
sistema deve evitar a ocorrência de resultados anômalos.

A importância da informação na maioria das organizações – que

estabelece o valor do banco de dados – tem determinado o
desenvolvimento de um grande conjunto de conceitos e técnicas para a
administração eficaz desses dados. (HEUSER, 2001)

33
3.4.1 – Persistência de Dados em Java e a especificação JPA

O termo persistência de dados provém da necessidade das aplicações

armazenarem os dados trabalhados em algum lugar, neste contexto esses dados
são comumente guardados em SGBDs, tais como (MySQL, PostgreSQL, SQL
Server, Firebird, etc). Cabe ressaltar que para esse trabalho usaremos como SGBD
o MySQL. Grande parte dos SGBDs é relacional, o que quer dizer “orientados a
colunas e linhas” conforme podemos visualizar na ilustração 9.

Ilustração 9 – Representação SGDB Relacional Fonte: http://www.macoratti.net

Em aplicações Java para realizar a persistência de dados foi utilizado durante

muito tempo os Java Database Connectivity – JDBC, que consiste basicamente em
um conjunto de classes e interfaces escritas em Java pelos fabricantes de SGBDs, o
JDBC realiza o envio de instruções da linguagem SQL para o banco de dados
tornado assim a persistência de dados relativamente simples. O problema deste
modelo é que enquanto a linguagem Java foi desenvolvida para ser utilizada com a
orientação a objeto, os SGBDs são relacionais, desta forma os desenvolvedores
consome um razoável tempo para converter de um paradigma para o outro. Para
(Cordeiro, 2012) a essa diferença chamou-se pelo nome de “Impedância Objeto-
Relacional (Impedance Mismatch)”, ele ainda faz o seguinte questionamento:

34
 Fazer essa conversão do mundo OO para o relacional cada vez que
precisamos salvar ou recuperar qualquer objeto do banco de dados exige
tanto esforço de desenvolvimento, que acabamos gastando alguma energia
com algo que não é o objetivo final do sistema. Não seria muito melhor se
essa integração entre os dois paradigmas já estivesse pronta e não
precisássemos nos preocupar com ela?

Com o intuito de resolver o problema da impedância objeto-relacional

algumas empresas e desenvolvedores começaram a trabalhar em projetos que
facilitasse esse trabalho, assim surgiu o conceito de Mapeamento Objeto Relacional
(Object Relational Mapping – ORM) e com ele as bibliotecas ORMs, sendo a mais
conhecida e utilizada o Hibernate (falaremos sobre ele no tópico 3.7.2). Abaixo na
ilustração 10 podemos ver o funcionamento do mapeamento objeto relaional.

Ilustração 10 – Funcionamento do Mapeamento Objeto Relacional Fonte:

http://www.devmedia.com.br

Essas bibliotecas facilita o trabalho de persistir dados no SGDB, tendo o

desenvolvedor apenas que fazer um mapeamento nas classes que terão seus dados
guardados, utilizando para isto a anotação @javax.persistence.Entity. Esse
mapeamento consiste em colocar a anotação acima, antes da declaração da classe
importando as dependências, assim, para persistir, por exemplo, uma classe
chamada Departamento no banco dados bastaria fazer conforme abaixo.
@Entity
public class Departamento {
@Id
@GeneratedValue
private Long id;
private String nome;

35
 @Column(name=”sigla_dpto”)
private String sigla;
@OneToOne
private Funcionario responsavel;
// getters e setters se necessário
}

Perceba que além da anotação já mencionada na classe há outras tais como

@Id, @OneToOne, etc. Cada uma das anotações realiza alguma tarefa especifica
no banco de dados, não necessitando mais o desenvolvedor se preocupar com os
dois paradigmas para desenvolver seus softwares. Após, o surgimento do conceito
de ORM, o mundo de desenvolvimento teve outro problema que novamente precisou
ser buscada uma solução que atendesse a contento os envolvidos. O problema foi
que surgiram muitas ferramentas ORM para realizar o trabalho de persistir dados,
porém esse é parte do problema, já que a outra parte era como cada uma delas
implementava o conceito. (Cordeiro, 2012) afirma a respeito do problema:
Dessa forma, chegou-se a um cenário onde muitas bibliotecas existiam,
para resolver o mesmo problema, mas cada uma fazendo o trabalho à sua
maneira, portanto, portabilidade passou a ser um problema, pois se você
usasse qualquer uma das bibliotecas, ela não seria compatível com outras
que já existiam no mercado, e isso cria o famoso vendor lock-in, ou seja,
uma vez usando determinada distribuição, ficava-se preso a mesma.

Para resolver este novo problema o mercado junto com os mantedores da

linguagem Java lançaram uma especificação detalhando as características mínimas
que um framework ORM deveria implementar, assim, surgiu a Java Persistence API
- JPA. Essa mudança na pratica não representou grandes alterações na forma como
os desenvolvedores estavam programando seus softwares, isto para quem usava o
Hibernate com ferramenta ORM, já que grande parte da especificação pegou como
característica as já existentes nesta ferramenta. Sobre o assunto (Cordeiro, 2012)
afirma “Essa nova especificação, não representou grandes alterações na forma de
usar um ORM, para quem já estava com o Hibernate, pois, entre algumas poucas
diferenças destacam-se os nomes dos métodos e das classes que devem ser
usadas”. Abaixo podemos verificar através da ilustração 11, como o JPA faz seu
trabalho.

36
 Hibernate

Ilustração 11 – Funcionamento do JPA(Provider Hibernate) Fonte: http://www.theopentutorials.com

3.5 – Contêineres para aplicações web

Para definir servidores ou contêiner para aplicações web é necessário

recorrer à explicação de (MORIMOTO, 2008) e (DA SILVA, 2008).
Um servidor é uma máquina que fica o tempo todo ligada, sempre fazendo a
mesma coisa. Existem vários tipos de servidores, como servidores web,
servidores de arquivos, servidores de impressão, etc., sendo que uma única
máquina pode rodar simultaneamente vários serviços, dependendo apenas
dos recursos de hardware e da carga de trabalho.

O servidor web é um programa responsável por disponibilizar páginas, fotos,

ou qualquer outro tipo de objeto ao navegador do cliente. Ele também pode
operar recebendo dados do cliente, processando e enviando o resultado
para que o cliente possa tomar a ação desejada (como em aplicações
CGI's, banco de dados web, preenchimento de formulários, etc).

Dentro do contexto apresentado, este trabalho pretende abordar os servidores

web, que serão utilizados no projeto proposto. Servidores web são utilizados para
disponibilizar aplicações a usuários da grande rede, funciona como o próprio nome
define, ou seja, servindo conteúdo aos usuários/clientes solicitantes. Desta forma,

37
estas máquinas ficam aguardando uma solicitação e ao recebê-la, ele processa o
pedido e devolve a resposta.
Este trabalho usará o servidor web denominado Apache Tomcat em sua
versão 7.0, mantido pela Apache Software Foundation, sob a licença Apache versão
2, que entre outras características preserva o fato do código ser aberto, ou seja,
open source. O Apache é um servidor robusto, altamente configurável, é flexível
podendo ser utilizado em diferentes plataformas, fornece o código-fonte completo,
está sempre em constante atualização para incorporações de novos protocolos, é
composto de módulos sendo cada um implementado com características para
aumento de suas funcionalidades, provêm um alto desempenho, além de outras
características.

3.6 – Linguagem de Programação Java para Web e o Padrão de Projeto MVC

A linguagem de programação Java teve seu primeiro projeto voltado para web
com o surgimento da tecnologia Servlet e após ela várias outras surgiram, mas
sempre baseadas na mesma. Abaixo podemos verificar um pouco de cada uma
delas.
 Servlets  Muito utilizadas nas primeiras aplicações web feitas em
Java. Porém, era muito complexa de usar, já que demandava
conhecimento de como os dados eram capturados e manipulados
pelos métodos GET e POST, além de ter que escrever todo o código
HTML dentro do código Java, mas o problema mais evidente estava
em ter que manter as aplicações conforme iam ganhando corpo, já que
não era fácil deixar todas as tecnologias juntas.

 JSP  Veio para melhorar e facilitar o desenvolvimento de aplicações

para web em Java, também teve muita importância no mercado de
software Java para web, mas tinham problemas, pois misturavam as
tags do Java dentro do corpo das tags HTML deixando o código
poluído como definiu o mercado.

38
  JSTL4  Essa especificação Java facilitou o desenvolvimento já que
separava os códigos escritos deixando dentro do HTML somente o
essencial para a execução do software.

 JSF 1.0  Resolveu os problemas anteriores isolando as tags HTML e

Java isto fazendo uso do melhor de cada uma das tecnologias
anteriores, ou seja, Servlets, JSP e JSTL. O maior problema deste
framework foi fazer uso expressivo dos arquivos XML.

Ilustração 12 – Visão geral do framework JSF Fonte: wwwespecializa.com.br

 JSF 2.0  Veio para suprir algumas lacunas existentes na versão

anterior faz parte da especificação JSR 314, fortemente baseado no
modelo MVC, ou seja, trabalha de forma onde há uma separação de
responsabilidade entre as partes do software, faz forte uso de
componentes, usa uma tecnologia denominada Facelets (falaremos
sobre essa tecnologia no tópico 3.7.3) para a formatação de interfaces
e reutilização das mesmas. Possui uma forte ligação com os Managed
Beans que são classes Java para realizar o controle da aplicação.

4 JSTL - Java Standard Tag Library

39
Ilustração 13 – Visão geral da Evolução do Java para web Fonte: wwwespecializa.com.br

Ilustração 14 – Arquitetura JSF Fonte: wwwespecializa.com.br

3.6.1 – Padrão de Projeto Modelo Visão Controle (Model View Controller) - MVC

O padrão de projeto MVC consiste em distribuir o programa em camadas

conforme a responsabilidade de cada parte do código, desta forma o projeto fica fácil
de manter e expansível. Conforme os autores (SILVEIRA; LOPES; MOREIRA;
STEPPAT, KUNG, 2012).

40
 Código HTML misturado com SQL e lógica de negócios em Java é
especialmente difícil de manter, além de o reúso ser baixo; mas,
infelizmente, este ainda é um dos grandes responsáveis pelo alto custo de
manutenção de código legado.

Dentro deste conceito cada parte do código fica com uma

responsabilidade assim temos que:
 Visão – View  Nas palavras de (Cordeiro, 2012) a visão representa a
parte de código que interage com o usuário, sendo assim são nossos
arquivos xhtml, JSPs, css, imagens, Javascript, etc. Esta camada está
apenas coisas relacionada a apresentação ao usuário;
 Modelo – Model  É a camada inteligente do nosso sistema, onde
nossas lógicas estão embutidas.
 Controler – Controller  Camada intermediária que esta entre o
modelo e a visão, sua responsabilidade e a de gerenciar a aplicação,
ou seja, receber as solicitações dos usuários através da visão e saber
direciona-la ao modelo correspondente e novamente receber os dados
do processo do modelo para repassa-la a visão.

Na ilustração 15 podemos observar como o padrão MVC funciona.

Ilustração 15 – Exemplo padrão MVC Fonte: www.klebermota.eti.br

41
3.7 – Frameworks para desenvolvimento

São componentes de software com o objetivo primário de facilitar o

desenvolvimento de outros softwares, geralmente mantidos por profissionais muito
experientes ou até mesmo por empresas entidades.
Em Java contamos além de outros no desenvolvimento para web com os
seguintes frameworks:
 Struts  Frameworks desenvolvido originalmente por Craig
McClanahan e doado a Apache Software Foundation em 2002.
(Caelum, 2010) agurmenta que “o Struts foi um dos primeiros
frameworks MVC com a ideia de se criar um controlador reutilizável
entre projetos. Ele foi lançado no ano 2000 com o objetivo de tornar
mais simples a criação de aplicações Web com a linguagem Java ao
disponibilizar uma série de funcionalidades já prontas”.

 SpringMVC  (Caelum, 2010) descreve este framework como sendo

“um framework moderno que usa os recursos atuais da linguagem
além de usar todo poder do container Spring”.

 JSF (Java Server Faces)  Um dos últimos framaworks a ser

especificados, permite construir aplicações web tratando
especialmente da camada de visão, onde ao invés de tags como
estávamos acostumados ele implementa componentes de tela.

 VRaptor  É um framework MVC brasileiro opensource com grande

comunidade de desenvolvedores e usuários e com documentação em
português.

3.7.1 – Java Server Faces – JSF

O Java Server Faces ou simplesmente JSF é conforme descreve (LUCKOW,

MELO, 2010) “uma especificação para um framework de componentes para o
desenvolvimento web em Java”. Por ser uma especificação conta com o apoio de
grandes corporações tais como: Apache, EDS, EMC, Hewlett-Packard, IBM,
42
Macromedia, entre outras. Ser uma especificação quer dizer que não é um produto
de fato, mas sim uma documentação para quem quer desenvolver frameworks para
JSF. Desta forma para usarmos o JSF tem que recorrer a um de seus
implementadores listamos os principais na tabela abaixo.
Organização Nome da Implementação Localização
Oracle (Antiga Mojarra https://javaserverfaces.java.net
SUN)
Fundation Apache MyFaces http://myfaces.apache.org
Oracle Oracle Application http://www.oracle.com
Development Framework -
Oracle ADF
Backbase Backbase http://www.backbase.com
NetAdvantage NetAdvantage http://www.infragistics.com
Tabela 3 – Implementações JSF Fonte: Elaborado pelo autor

No site http://www.jsfmatrix.net podemos conhecer as diferenças entre cada

uma das implementações, além de conhecer outras não presentes na tabela 2.
Para usarmos o JSF temos que ter um servidor web (conteiner) como o
Tomcat 7, por exemplo, ou GlassFish. Temos ainda, no caso do Tomcat e alguns
outros servidores que baixar e importar as seguintes bibliotecas.
 jsf-api.jar;
 jsf-impl.jar;
 jstl-1.xx.jar;
 commons-beanutils-xx.jar;
 commons-collections-xx.jar;
 commons-digester-xx.jar;
 commons-logging-xx.jar.

O próximo passo é acrescentar ao nosso arquivo web.xml da nossa

aplicação o trecho de código abaixo.
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.jsf</url-pattern>
</servlet-mapping>

43
 No uso do JSF temos que ter em mente que não estamos codificando tags
como fazia no passado, cada abertura de código é um componente e este pode
pertencer a dos dois tipos que a especificação determina, são eles:
 Componentes Core  Conforme (LUCKOW, MELO, 2010), este
componentes “são como utilitários para as demais componentes do JSF,
inclusive os de terceiros”. Sua declaração dever ser:
xmlns:f=http://Java.sun.com/jsf/core
 Componentes HTML  Contêm conforme (LUCKOW, MELO, 2010), as
“tags que correspondem diretamente as tags do HTML, com a diferença de
que essas tags no JSF são componentes e estarão diretamente ligadas à
inteligência da aplicação”. Sua declaração dever ser:
 xmlns:h=http://Java.sun.com/jsf/html

Detalhamos na tabela 4 e 5 alguns dos principais componentes de cada um dos

dois grupos conforme já citados por (LUCKOW, MELO, 2010):
Componentes do conjunto CORE
Tag Descrição
(Componente)
actionListener Permite registrar uma ação a ser realizada por um
componente.
ajax Permite registrar uma ação a ajax a ser realizada pelo
acionamento de alguma funcionalidade.
converter Permite registrar um conversor personalizado para um
componente.
event Permite registrar uma classe para ser acionada em
determinado eventos relativos a um componente.
facet Muito utilizada para preenchimentos de datatable e permite
definir um conteúdo que será mostrado no header ou no footer
do componente.
param Permite definir um parâmetro para substituição de texto para a
tag <f:outputFormat>
selectItem Adiciona um item de valor a um componente de seleção de
valores, tais como o <h:selectOneMenu>
setPropertyAction Permite atribuir um valor a um determinado alvo(método) de
Listener algum bean.
Obs: Mais compomentes podem ser localizados em:
https://javaserverfaces.java.net/nonav/docs/2.0/javadocs/index.html
Tabela 4 – Componentes do grupo Core do JSF Fonte: Adaptado pelo autor

Componentes do conjunto HTML

Tag Descrição
(Componente)
44
body Representa a tag body do HTML
datatable Representa uma tabela do HTML que pode ser gerada e
manipulada dinamicamente
commandButton Gera um botão para submeter um formulário ou reseta-lo,
precisa esta dentro de um <h:form> para funcionar.
form Provém um form semelhante ao do HTML
head Representa o head do HTML
inputText Representa um input do HTML
message Mostra um texto de mensagem dentro de um form
selectOneMenu Possibilita chamar uma opção dentro de um menu suspenso.
Obs: Mais compomentes podem ser localizados em:
https://javaserverfaces.java.net/nonav/docs/2.0/javadocs/index.html
Tabela 5 – Componentes do grupo HTML do JSF Fonte: Adaptado pelo autor

Abaixo apresentamos uma pagina juntamente com o código contendo alguns

dos componentes mostrados nas tabelas acima, ressaltamos que este exemplo é
trivial e serve apenas para demonstrar como codificar a página.

Ilustração 16 – Exemplo pagina usando JSF Fonte: Autor

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets">
<h:head>Pagina de Exemplo dos Componentes HTML do JSF</h:head>
<h:body>
<h:form>
<h:messages />
<h:panelGrid columns="2">
<h:outputText value="Nome:" />
<h:inputText id="nome" size="20"/>
<h:outputText value="Idade:" />
<h:inputText id="idade"/>
<h:outputText value="Faixa Salarial:" />
45
 <h:selectOneMenu id="faixaSalario">
<f:selectItem itemLabel="Até 1 salário" itemValue="1"/>
<f:selectItem itemLabel="Até 2 salário" itemValue="2"/>
<f:selectItem itemLabel="Mais de 3 salário" itemValue="3"/>
</h:selectOneMenu>
<h:commandButton value="Executar" />
</h:panelGrid>
<h:dataTable border="1">
<h:column>
<f:facet name="header">Administrador</f:facet>
<h:outputText value="Administrador" />
</h:column>
<h:column>
<f:facet name="header">Analista Tecnico</f:facet>
<h:outputText value="Analista" />
</h:column>
</h:dataTable>
</h:form>
</h:body>
</html>

A página acima não tem nada de especial, isto porque tirando o fato de já
aparecer no navegador quando solicitada pelo endereço correto, não implementa
nenhuma ação. Em JSF cada arquivo com a extensão .xhtml(JSF) pode ser ligado a
uma ou mais classes Java. Estas classes são conhecidas como Bean (Backing
Bean). (LUCKOW, MELO, 2010) descrevem estas classes da seguinte maneira:
A classe Bean (conhecidas também como Backing Bean) é uma classe Java
normal, que suportará todo o funcionamento das paginas JSF. Isso permite
que você desenvolva seu projeto separando as regras de funcionamento da
organização visual da página e do layout.

Como vimos estas classes forneceram todas as informações e operações que

serão executadas nas páginas, tais como, o acionamento de um botão através de
um formulário presente na pagina, faz com que este dispare um método na classe.
Porem, para que haja esta ligação temos que fazer uma das duas opções:
 Mapear a classe no arquivo faces-config.xml  Na primeira versão
da JSF está era a única opção existente, ela apesar de fornecer este
vinculo causou muitas criticas ao framework por parte de alguns
desenvolvedores que reclamavam da quantidade de configuração
presentes. Para utilizar esta abordagem é necessário inserir no arquivo
acima as linhas de código abaixo.
<managed-bean>
< managed-bean-name>nomeManagedBean</ managed-bean-
name>
< managed-bean-class>xx.classeManagedBean</ managed-bean-
class>
< managed-bean-scopo>escopoManagedBean</ managed-bean-class>
46
 </managed-bean>

 Anotações  Tornou o framework muito mais moderno e fácil de

configurar, agora ao invés de ficar colocando várias linhas de código
em um arquivo .xml, o desenvolvedor apenas tem que acrescentar
algumas linhas na própria classe. Além de seguir uma tendência de
outros projetos que utilizam das anotações para serem configurados.
Abaixo um exemplo de utilização desta abordagem.
package br.to.gov.beans;
//importes omitidos

@ManagedBean
@RequestScoped
public class CelaBean implements Serializable{
private Cela cela;
//Gets e Sets
}
Um dos cuidados que todo desenvolvedor deve ter ao trabalhar com o JSF é
quanto ao ciclo de vida das suas requisições, que é como o JSF se comporta
internamente quando está processando uma página. Este ciclo de vida é dividido em
sete fases, isto se ele for processado corretamente, além de outras variáveis que
pode influenciar o ciclo. Na ilustração 17 e 18 temos duas visões de como o JSF se
comporta ao processar uma página.

Ilustração 17 – Ciclo de vida pagina JSF Fonte: victorsato.com

47
Ilustração 18 – Ciclo de vida pagina JSF visão do processamento Fonte: http://osl2.uca.es
Abaixo uma breve explicação sobre cada uma das fases mostradas acima.
1. Restore View  Carrega em memória a pagina solicitada, isto se ele
já não estiver lá, ou seja, caso ela seja nova;
2. Aplly Request Values  O JSF preenche a árvore de componentes
da página com os valores da requisição, isto se, o componente não
estiver marcado com a opção immediate=true.
3. Process Events  O JSF navega pelos componentes e registra os
eventos.
4. Process Validation  O JSF percorre os componentes validando as
regras codificadas pelo desenvolvedor, caso alguma delas seja
invalidada ele reexibe a página mostrando o erro.
5. Update Model Values  Somente neste passo é que o JSF atualiza o
modelo de dados, ou seja, nas classes beans, isto porque aqui ele já
tem a certeza que todos os dados foram devidamente validados e os
eventos processados. Também é nesta fase que ocorrem as
conversões básicas da linguagem Java.
6. Invoke Application  Nesta fase o JSF, após ter certeza das fases
anteriores terem sido processadas e validadas, chama o método que
foi configurado ao processar o formulário.
7. Render Responde  Aqui o JSF monta através de seus componentes
o HTML para que o navegador possa disponibilizá-lo ao solicitante.
48
3.7.2 – Hibernate

No tópico 3.4.1, abordamos a respeito da JPA, naquela oportunidade vimos

que esta não é uma ferramenta que podemos utiliza-la diretamente em nos nossos
projetos, pois, trata-se de uma especificação para que todos que desenvolvam
frameworks para persistência de dados possam implementa-la em suas ferramentas.
Sendo assim para que possamos aproveitar todo o potencial que a JPA fornece aos
projetos precisamos utilizar um provedor (Provider). O Hibernate é sem dúvida um
dos provedores de JPA mais conhecidos, alias muitas das características deste
framework foi absorvida pela especificação JPA. Para (CORDEIRO, 2012), uma das
funcionalidades destes provedores de JPA como o Hibernate é a capacidade de:
Abstração de bancos de dados. Dessa forma, não é necessário modificar o
código da aplicação quando trocamos um banco de dados por outro. Uma
das bases para isso são justamente a existência de diversos dialetos, que
representam as diferenças dos SQLs para cada banco de dados.

Para configurar o Hibernate no projeto necessitamos baixar do site do projeto

aos arquivos com as extensões .jar, estes arquivos são basicamente os abaixo:
antlr-xx.jar javassist-xx.jar banco-connector-java.jar
commons-collections-xx.jar jta-xx.jar hibernate-jpa-xx.jar
dom4j-xx.jar slf4j-simple-xx.jar
hibernate-xx.jar slf4j-api-xx.jar
Tabela 6 – Lista arquivos da configuração Hibernate e JPA Fonte: Adaptado pelo autor

Observe que o “xx” é a versão do arquivo ao qual vamos trabalhar e o arquivo

banco-connector-java.jar, é o conector Java para o banco de dados no qual vamos
usar. Outra informação que temos nesta lista é hibernate-jpa-xx.jar, trata-se do
arquivo que diz a aplicação e ao Hibernate que utilizaremos as definições da JPA.
Logo após acrescentar estes arquivos na lib do projeto temos que criar o
arquivo hibernate.cfg.xml, caso em que utilizaremos apenas o Hibernate para
persistir os dados, ou o Persistence.xml nesta situação usaremos o Hibernate,
porém com as definições da JPA. Na ilustração 19 e 20 há um exemplo dos dois
arquivos.

49
Ilustração 19 – Exemplo de configuração arquivo Hibernate.cfg.xml Fonte: http://tech-
gcs.blogspot.com

50
Ilustração 20 – Exemplo de configuração arquivo persistence.xml
Fonte: http://blog.camilolopes.com.br

Podemos observar através dos arquivos que eles são muito próximos com
exceção de algumas propriedades, olhando mais atentamente veremos inclusive
que no arquivo persistence.xml fazemos referência ao Hibernate.
Uma característica muito importante que o uso de JPA/Hibernate pode
proporcionar ao desenvolvedor é a capacidade de criação e destruição das tabelas
do banco de dados. Para usarmos essa propriedade basta acrescentar no código
acima a seguinte linha: <property name="hibernate.hbm2ddl.auto" value="update"/>. Desta
forma estamos informando ao Hibernate que ele deve criar e alterar as nossas
tabelas automaticamente. Outras possibilidades segundo (CORDEIRO, 2012) são:
 create  Nesta propriedade o Hibernate sempre recria todas as
tabelas na base de dados, assim o desenvolvedor trabalha sempre
com um base limpa;
 create-drop  As tabelas são criadas e excluídas no final da
execução, caso solicitado pelo desenvolvedor;
 validate  Não cria e nem apaga nada, apenas valida se as entidades
estão de acordo com as tabelas, lançando uma exceção caso
contrário;

51
  update  Essa propriedade é a mais indicada para aplicações em
produção, pois sua tarefa é manter os dados e criar os solicitado,
nunca apagar os existentes.

3.7.3 – Facelets

Essa tecnologia foi incorporada na JSF 2 conforme descreve (COELHO,

2012). Tem por finalidade fornecer meios de utilizar um esquema de Template nas
páginas .xhtml, desta forma reaproveitando boa parte do código produzido no que se
refere a parte estrutural das páginas.
Para utilizar a Facelets temos que primeiramente definir nos arquivos .xhtml o
seu namespace xmlns:ui=http://java.sun.com/jsf/facelets, o outro passo é criar uma
estrutura em um arquivo de folha de estilo (.css) normal, após esta definição a
próxima etapa é criar o arquivo template, sendo este um arquivo .xhtml usando a
estrutura definida no arquivo de estilo. Abaixo através das próximas ilustrações
demonstraremos os passos para a utilização da tecnologia os comentários estão em
vermelhos.

Ilustração 21 – Definição de um arquivo de estilo Fonte: Autor

52
Ilustração 22 – Definição de um Tamplate em Facelets Fonte: Autor

Ilustração 23 – Definição de arquivo usando o template anterior Fonte: Autor

53
3.7.4 – Biblioteca de componentes - Primefaces

É uma biblioteca que tem como premissa facilitar a vida do desenvolvedor isto
através de vários componentes prontos que podemos incluir no nosso código. Foi
uma das primeiras a estar totalmente convertida para o JSF 2 segundo (LUCKOW,
MELO, 2010). A instalação é muito simples, são apenas dois passos, o primeiro é
incluir na lib do projeto a biblioteca primefaces-x.x.jar, e o segundo é incluir nos
arquivos .xhtml que irão usar os componentes o namespace
xmlns:p="http://primefaces.org/ui.
Está biblioteca é muito rica e disponibiliza um grande número de
componentes e temas, deixando a aplicação muito mais dinâmica e interativa,
diminuindo muito o trabalho dos desenvolvedores. Alguns dos componentes desta
biblioteca poderão ser vistos juntamente com uma curta descrição do uso e uma
imagem da saída na tabela 7.

Nome Utilidade Imagem

Componente
Calendar Pop-up de calendário. Pode ser
colocado junto a um campo ou
acionado via ícone.

AutoComplete Permite apresentar sugestões de

valores para o campo sendo este
carregado de alguma base de
dados ou arquivo.

Captcha Recurso indispensáveis e sites

com formulários hoje na web,
fornece uma imagem
embaralhada para confirma se
quem esta inserindo os dados não

54
 é um robô.
InputMask Fornece mascaras para os
campos de um formulário, sendo
possível a personalizações das
mesmas de acordo com a
necessidade.
Collector Gerencia as operações de
adicionar objetos em listas.

ConfirmDialog Possibilita apresentar um Diálogo

com o usuário de forma
personalizada.

Editor Como o próprio nome sugere cria

um rico editor de texto com vários
componentes.

Growl Substitui as mensagens padrão do

JSF por janelas flutuantes

TabView Permite a exibição de

componentes em formato de abas

Wizard Permite o preenchimento de

formulário em forma de assistente.

Tooltip Fornece uma mensagem ao

passar o mouse sobre algum
componente

55
GMap Fornece um mapa no padrão do
serviços oferecidos pelo
GoogleMap

Tabela 7 – Componentes do Primefaces Fonte: Adaptado pelo autor

Como podemos verificar esta é uma ferramenta muito interessante para

enriquecer o projeto de um software, cabe ressaltar que apresentamos apenas
algumas dos vários componentes possíveis. No endereço
http://www.primefaces.org/showcase há outros que poderão ser utilizados.

56
4 – PROJETO: Sistema de Gestão Penitenciário - SISGESPEN

4.1 – Introdução ao Problema

O projeto SISGESPEN, propõe-se a desenvolver uma ferramenta capaz de

fornecer informações detalhadas sobre cada individuo preso no sistema prisional do
estado do Tocantins. Através destas informações os gestores poderão traçar
alternativa individual para cada uma destas pessoas, pois conhecerão os problemas
pelos quais cada um passou até entrar no sistema, ou seja, sua historia de vida.
Para que a ferramenta compra com sua finalidade e em consequência das
particularidades do sistema prisional estudado, ela terá que possuir algumas
características fundamentais. Entre os atributos funcionais necessários o software
precisará ter os relacionados na tabela abaixo.
CARACTERISTICAS DO SISGESPEN
Ser baseado no modelo cliente-servidor Possibilidade de perfis de acesso por
e acessível pelo navegador web categoria de serviços
Possuir uma única base de dados Possuir gerenciamento dos Agentes
envolvidos na guarda dos internos
Ser multi usuário Possuir gerenciamento das unidades
onde há comprimento de penas
Possuir gerenciamento dos Internos Possibilidade do registro de Advogados
presos e seus dados socioeconômicos e e das visitas de cada Interno
outros.
Possibilidade de impressão de relatórios Possibilidade de consultas rápidas para
obtenção de informações
Tabela 8 – Características do SISGESPEN Fonte: Autor

4.2 – Estudo da Estrutura funcional da Secretaria de Defesa Social - SEDS

Para uma melhor compreensão do problema a ser solucionado, analisamos a

estrutura da SEDS para obtenção de mais informações. Após, a averiguação
chegamos ao organograma abaixo.

57
Ilustração 24 – Organograma Secretaria da Defesa Social – SEDS (Ex-Secretaria da Justiça e dos Direitos Humanos) Fonte: Autor

58
4.3 – Modelagem do Problema a ser resolvido

Com base nas informações obtidas nos tópicos anteriores partimos para a
entrevista com os envolvidos para ratificação do modelo e aprimoramento das
informações colhidas. Assim, entrevistamos a Diretora de Assistência ao Preso e ao
Egresso como também o diretor de Administração Prisional e Penitenciário e por fim
alguns agentes penitenciários acostumados com o dia a dia das unidades, obtendo
assim várias informações adicionais.
Uma das informações que colhemos foi à existência de uma pequena base de
dados utilizada nas unidades para catalogar dados dos internos, alias apesar de não
suprir as necessidades por ser bastante limita, esta é muito utilizada.

4.3.1 – Pesquisa para Obtenção dos Diagramas

Conforme citamos no tópico anterior a descoberta da pequena base serviu

para que posássemos aprimorar ainda mais as características do projeto a ser
desenvolvido, tendo este servidor para obtenção de várias características
necessárias para o projeto. Dele por exemplo foi possível abstrair os modelos
apresentados nos tópicos 4.4.1 e 4.4.2.

4.3.2 – Diagramas de Caso de Uso - SISGEPEN

No diagrama de caso de uso utilizamos a técnica de (MELO, 2004), onde

descrevemos algumas características em forma de tabela para aperfeiçoamento do
modelo e validação do mesmo. Após este trabalho chegamos ao modelo de tabela e
diagrama abaixo.
Nome do Caso de Uso: Manter Unidades
Objetivo: Cadastrar ou manter atualizado o registro de unidades onde há guarda
de presos
Ator: Agente Administrador
Cenário Principal:
1. O agente loga na aplicação.
2. O sistema mostra as opções disponíveis de acordo com o perfil do agente.
3. O agente escolhe cadastrar ou alterar uma unidade.
4. O sistema mostrar o formulário com os campos em branco se for para novo
registro ou preenchidos se for para alteração.
5. O agente realizar a inserção de dados e clica em salvar ou atualizar.
6. O Sistema realiza a inserção dos dados.
Cenário Secundário:
1a – O login está incorreto ou a senha é invalida o sistema exibe novamente a tela
59
de login com a mensagem informando o erro.
4a – O sistema inabilitara os campos que não poderão ser alterados como a data
de cadastro e o código da unidade.
5a – O sistema realiza a validação e conversão dos dados inseridos e caso seja
uma unidade já cadastrada apresenta o formulário novamente com uma mensagem
informando o erro ao agente.
5b – Caso os dados inseridos não respeite as regras preenchimento o sistema
apresenta o formulário novamente com uma mensagem ao usuário indicando os
campos com pendências.
Tabela 9 – Caso de Uso Manter Unidades Fonte: Autor

Ilustração 25 – Diagrama de Caso de Uso Fonte: Autor

4.3.3 – Diagramas de Classe - SISGEPEN

Para a obtenção do diagrama de classes e por fim o desenvolvimento do

software foi necessárias várias analises dos dados em mãos em reuniões com os
envolvidos, resultando finalmente no modelo apresentado na ilustração 25. Cabe
ressaltar ainda que parte do modelo foi retirada do arquivo que informado no tópico
4.3 através de observação do funcionamento.

60
Ilustração 26 – Diagrama de Classe Fonte: Autor

61
4.4 – Configurações para a persistência via JPA

Nas configurações da JPA introduzimos na propriedade <property

name="hibernate.hbm2ddl.auto" value="update"/> do arquivo Persistence.xml a configuração

update para que a própria aplicação controle a criação e atualização das tabelas do
nosso banco de dados facilitando assim a manutenção da aplicação.

4.5 – Modelos de dados

O projeto SISGESPEN foi elaborado e codificado seguido os padrões de

configurações por convenções da JPA, sendo assim o nome das tabelas no banco
de dados são gerados com o mesmo nome das classes assim como os campos tem
o nome dos atributos, desta forma tanto o crescimento da aplicação quanto as
manutenções serão mais fáceis.

4.6 – Telas do Projeto – SISGESPEN

Abaixo apresentamos algumas telas da aplicação outras poderão ser

observadas nos apêndices.

Ilustração 27 – Tela de login do SISGESPEN Fonte: Autor

62
Ilustração 28 – Tela principal do SISGESPEN Fonte: Autor

63
5 – CONCLUSÃO

5.1 – Considerações Finais

O desenvolvimento de aplicações em Java para web agregando as

tecnologias e ferramentas (JPA/Hibernate, Primefaces, Facelets, JSF2,
JasperReporter e MVC), podem trazer vários benefícios ao projeto, tais como:
 Agilidade na codificação;
 Componentes ricos;
 Abstração do manuseio da base de dados;
 Facilidade de manutenção;
 Componentização;
 Divisão de responsabilidades;
 Geração de relatórios em diversos formatos entre outros;
No entanto, alguns aspectos deverão ser observados para evitar perda de
tempo e desgaste na equipe, enumeramos alguns destes cuidados abaixo de acordo
com cada tecnologia.
JavaServer Faces 2.
1. O ciclo de vida do JSF deve ser claramente entendido;
2. O escopo dos beans deve ser friamente estudado.
JPA 2 e Hibernate
1. O mapeamento das entidades deve ser realizado com muita atenção;
2. Ter muito cuidado com os relacionamentos tanto os unidirecionais
quanto os bidirecionais, principalmente este ultimo;
3. Entender como funciona as operações em cascata;
4. Compreender o ciclo de vida de um objeto;
5. Atentar para os tipos de carregamentos Lazy e Eager.
Biblioteca de Componentes Primefaces
1. Atentar para a versão da biblioteca;
2. Nos componente Ajax observar o escopo dos beans juntamente com o
ciclo de vida da JPA e JSF.

Seguindo as orientações apresentadas temos um ambiente produtivo e muito

elegante.
5.2 – Trabalhos Futuros

A ferramenta desenvolvida durante a elaboração do projeto esta em sua fase

embrionária se bem aprimorada pode cobrir a carência de informações do sistema
penitenciário servido de subsídios para a lacuna na ressocialização dos presos. Isto
por que não se muda o que não se conhece, e com essa ferramenta a gestão
prisional do estado passara a conta com uma base de informações do perfil de cada
individuo conhecendo os fatores que levou ele a estar nas prisões do estado.
 BIBLIOGRAFIA

AGÊNCIA ARAGUAIA CAPC. Tocantins: 75,6% dos presos não têm atividade.
Disponível em <http://www.folhadobico.com.br/06/2010/tocantins-756-dos-presos-
nao-tem-atividade.php> Acesso em maio de 2013.

ALGAWORKS. DWJSF. Desenvolvimento Web com JavaServer Faces.

Disponível em: <http://www.algaworks.com/downloads/apostilas/algaworks-
dwjsfdesenvolvimento-web-com-javaserver-faces-2a-edicao.pdf> Acesso em: maio.
2013.

BOOCH, RUMBAUGH, JACOBSON, Grady, James, Ivar, UML guia do usuário, 2ª

edição, Rio de Janeiro – RJ, Editora Campus, 2005.

CÂMERA DOS DEPUTADOS. CPI Sistema Carcerário. Brasília-DF: Biblioteca

Digital Câmera, 2009.

CASTRO, Juliana. Apenas 22% dos presos do sistema penitenciário brasileiro

trabalham. Disponível em: <http://oglobo.globo.com/pais/apenas-22-dos-presos-do-
sistema-penitenciario-brasileiro-trabalham-7861623> Acesso em: Abr de 2013.

CAELUM. FJ-26 Laboratório de MVC com Hibernate e JSF para Web. Disponível
em: <www.caelum.com.br> Acesso em maio de 2013.

COELHO, Hébert. JSF Eficaz As melhores práticas para o desenvolvedor web

Java. São Paulo – SP. Editora Casa do Código, 2012.

CORDEIRO, Gilliard. Aplicações Java para web com JSF e JPA. São Paulo-SP.
Editora Casa do Código, 2012.

CURSO E COLÉGIO ALLIANÇA. Sistema carcerário brasileiro a realidade

trancafiada. Disponível em: <http://blogcolegioallianca.com.br/sistema-carcerario-
brasileiro-a-realidade-trancafiada/> Acesso em maio de 2013.

DE MELO e LUCKOW, Décio Heinzelmann e Alexandre Altair. Programação Java

para web. São Paulo-SP: Editora Novatec, 2010.

FOLHA ONLINE. Criminalista mostra por que as prisões brasileiras falham.

Disponível em: <www1.folha.uol.com.br/folha/publifolha/ult10037u351830.shtml>
Acesso em maio de 2013.

GONÇALVES, Edson. Desenvolvendo Aplicações web com JSP, Servlets,

JavaServer Faces, Hibernate, EJB 3 Persistence e Ajax. Editora Ciência
Moderna, 2007.

JULIÃO, Elionaldo Fernandes. A ressocialização através do estudo e do trabalho

no sistema penitenciário brasileiro. Rio de Janeiro – RJ: UERJ, 2009.
MINISTÉRIO DA JUSTIÇA. Fundo Penitenciário Nacional – FUNPEN em
números. 6ª Edição. Brasília-DF, 2012.

K19 TREINAMENTOS. Desenvolvendo Web com JSF2 e JPA2 – versão agosto

2012. Disponível em: <www.k19.com.br> Acesso em maio de 2013.

K19 TREINAMENTOS. Desenvolvendo Web Avançado com JSF2, EJB3.1 e CDI.

Disponível em: <www.k19.com.br> Acesso em maio de 2013.

MELO, Ana Cristina, Desenvolvendo Aplicações com UML 2.0 – Do conceitual à

implentação, 2ª edição, Rio de Janeiro – RJ, Editora Brasport, 2004.

MINITÉRIO DA JUSTIÇA – DEPARTAMENTO PENITENCIÁRIO NACIONAL –

DEPEN. Percentual de Preenchimento de indicadores por mês/ano. Brasília-DF,
2013.

MINITÉRIO DA JUSTIÇA – DEPARTAMENTO PENITENCIÁRIO NACIONAL –

DEPEN. Sistema Penitenciário no Brasil Dados Consolidados - 2008. Brasília-
DF, 2008.

PAGE-JONES. Fundamentos do Desenho Orientado a Objeto com UML. São

Paulo-SP. Makron Books, 2001.

PROJECT MANAGEMENT INSTITUTE, Inc - PMI. Guia do Conhecimento em

Gerenciamento de Projetos (Guia PMBOK®). Newtown Square, Pennsylvania
EUA. 2008.

PRUDENTE, Meemias Moretti. Sistema Prisional Brasileiro: Desafios e

Soluções. Disponível em: <http://atualidadesdodireito.com.br/neemiasprudente /
2013/03/06/sistema-prisional-brasileiro-desafios-e-solucoes/> Acesso em maio de
2013.

SECRETARIA DA EDUCAÇÃO E SECRETARIA DE JUSTIÇA E DOS DIREITOS

HUMANOS DO TOCANTINS. Plano Estadual de Educação nas Prisões. Palmas-
TO, 2012.

SISTEMA PENITENCIÁRIO E PRISIONAL DO ESTADO DO TOCANTINS.

População Carcerária – Levantamento de dados referente ao mês de abril de
2013. Palmas-TO, 2013.

TV Brasil. Sistema Carcerário Brasileiro. Disponível em: <http://tvbrasil.ebc.com.br>

Acesso em maio de 2013.

VIANA, Johnnatan Reges. A crise do sistema carcerário brasileiro. Disponível em

:<http://www.meuadvogado.com.br/entenda/a-crise-do-sistema-carcerario-
brasileiro .html> Acesso em: maio de 2013.
 APÊNDICES

A – Arquivo Persistence.xml

Neste arquivo realizamos as configurações da JPA para acessar o banco de

dados. Utilizamos principalmente as configuração por padrão.

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.0" xmlns=http://java.sun.com/xml/ns/persistence
xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
<persistence-unit name="Sisgespen" transaction-type="RESOURCE_LOCAL">
<class>br.to.gov.modelo.Agente</class>
<class>br.to.gov.modelo.Permissao</class>
<class>br.to.gov.modelo.Estado</class>
<class>br.to.gov.modelo.Cidade</class>
<class>br.to.gov.modelo.Pais</class>
<class>br.to.gov.modelo.EstadoCivil</class>
<class>br.to.gov.modelo.TipoUnidade</class>
<class>br.to.gov.modelo.UnidadePrisional</class>
<class>br.to.gov.modelo.Pavilhao</class>
<class>br.to.gov.modelo.Cela</class>
<class>br.to.gov.modelo.Ocupacao</class>
<class>br.to.gov.modelo.GrauInstrucao</class>
<class>br.to.gov.modelo.Advogado</class>
<class>br.to.gov.modelo.Interno</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/Sisgespen"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="javax.persistence.jdbc.password" value="1205"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.format_sql" value="true"/>
</properties>
</persistence-unit>
</persistence>
B – Pacotes do sistema

Para uma melhor organização do código produzido e facilitar as manutenções

futuras o projeto foi dividido em pacotes e diretórios para agrupamentos de classes e
arquivos .xhtml.
C – Classe do pacote br.to.gov.JPAUtil.java

Para que a aplicação tivesse um único ponto de conexão com o banco de

dados foi elaborada a classe JPAUtil e a partir dela foi possível realizar os acessos
ao banco.
D – Classe do pacote br.to.gov.modelo.Advogado.java

package br.to.gov.modelo;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToOne;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@NamedQueries({
@NamedQuery(name = "Advogado.buscaPorCodigo", query="SELECT a FROM Advogado
a WHERE a.codigo = :codigo"),
@NamedQuery(name = "Advogado.buscaPorNome", query="SELECT a FROM Advogado a
WHERE a.nome LIKE :nome")
})
public class Advogado implements Serializable {
private static final long serialVersionUID = 1L;

@Id
@GeneratedValue
private Long codigo;
public static final String buscaPorNome = "Advogado.buscaPorNome";
private String nome;
 @Column(unique=true, nullable=false, updatable=false)
private String numeroOAB;
private String telefone;
private String endereco;
private String email;
private String celular;
@Column(updatable=false)
@Temporal(TemporalType.DATE)
private Date dataCadastro;
private String bairro;
@OneToOne
private Estado estado;
@OneToOne
private Cidade cidade;
public Long getCodigo() {
return codigo;
}
public static String getBuscapornome() {
return buscaPorNome;
}
//Gets e Sets e hashCode() e equals
}
E – Classe do pacote br.to.gov.modelo.Agente.java

package br.to.gov.modelo;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@NamedQueries({
@NamedQuery(name = "Agente.buscaPorNome", query="SELECT a FROM Agente
a WHERE a.nome LIKE :nome"),
@NamedQuery(name = "Agente.buscaPorLogin", query="SELECT a FROM
Agente a WHERE a.login = :login")
})
public class Agente implements Serializable{
private static final long serialVersionUID = 1L;

public static final String buscaPorNome = "Agente.buscaPorNome";

public static final String buscaPorLogin = "Agente.buscaPorLogin";
private Long codigo;
private String nome;
@Column(unique=true, nullable=false)
private String matricula;
private String telefone;
private String celular;
@Column(unique=true, nullable=false)
private String email;
@Column(unique=true, nullable=false)
@Id
private String login;
private String senha;
@Column(name = "ativo", columnDefinition = "BOOLEAN")
private boolean ativo;
@ManyToMany(cascade=CascadeType.REFRESH)
private List<Permissao> permissoes;
@ManyToOne
private UnidadePrisional lotacao;
@Temporal(value =TemporalType.DATE)
private Date inicioLotacao;
@Column(updatable=false)
@Temporal(TemporalType.DATE)
private Date dataCadastro;
//Gets e Sets e hashCode() e equals
}
F – Classe do pacote br.to.gov.modelo.Cela.java

import java.lang.String;
import javax.persistence.*;

/**
* Entity implementation class for Entity: Cela
*
*/
@Entity
public class Cela implements Serializable {
private static final long serialVersionUID = 1L;

@Id
@GeneratedValue
private Long codigo;
private int numero;
private String descricao;
private int capacidade;
@OneToOne
private UnidadePrisional unidadePrisional;
@OneToOne
private Pavilhao pavilhao;
//Gets e Sets e hashCode() e equals
}
G – Classe do pacote br.to.gov.modelo.Interno.java

package br.to.gov.modelo;

import br.to.gov.modelo.Cidade;
import br.to.gov.modelo.Estado;
import br.to.gov.modelo.EstadoCivil;
import br.to.gov.modelo.GrauInstrucao;
import br.to.gov.modelo.Ocupacao;
import br.to.gov.modelo.Pais;
import java.io.Serializable;
import java.lang.Long;
import java.lang.String;
import java.util.Date;
import javax.persistence.*;

/**
* Entity implementation class for Entity: Interno
*
*/
@Entity
@NamedQueries({
@NamedQuery(name = "Interno.buscaPorCodigo", query="SELECT i FROM
Interno i WHERE i.codigo = :codigo"),
@NamedQuery(name = "Interno.buscaPorApelido", query="SELECT i FROM
Interno i WHERE i.apelido LIKE :apelido"),
@NamedQuery(name = "Interno.buscaPorNome", query="SELECT i FROM
Interno i WHERE i.nome LIKE :nome")
})
public class Interno implements Serializable {
private static final long serialVersionUID = 1L;

@Id
@GeneratedValue
private Long codigo;
private String nome;
private static final String buscaPorApelido = "Interno.buscaPorApelido";
private static final String buscaPorNome = "Interno.buscaPorNome";
private String apelido;
private String sexo;
@Column(unique=true, nullable=true)
private String cpf;
private String rg;
private String rgExpedidor;
@OneToOne
private Cidade naturalDe;
@OneToOne
private Estado estado;
@OneToOne
private Pais nacionalidade;
@Temporal(TemporalType.DATE)
private Date dataNascimento;
@OneToOne
private Ocupacao ocupacao;
@OneToOne
private EstadoCivil estadoCivil;
private boolean convivemConjuge;
private String nomeConjuge;
 private String enderecoConjuge;
private String bairroConjuge;
@OneToOne
private Cidade cidadeConjuge;
@OneToOne
private Estado estadoConjuge;
private boolean temFilhos;
private int quantos;
private String codicoesSaudeFilhos;
private boolean convivemPais;
private boolean paiVivo;
private String nomePai;
private boolean maeViva;
private String nomeMae;
private String enderecoPais;
private String bairroPais;
@OneToOne
private Cidade cidadeDosPais;
@OneToOne
private Estado estadoDosPais;
private String racaEtnia;
private String rosto;
private String corOlhos;
private String sombrancelhas;
private String nariz;
private String barba;
private String cabelos;
private String dentes;
private String orelhas;
private String pescoso;
private String compleicao;
private double estatura;
private double ultimaRenda;
private String religiao;
@OneToOne
private GrauInstrucao grauInstrucao;
private String tatuagem;
private String formaTatuagem;
private String cicatriz;
private String defeitosFisicos;
private String amputacoes;
//Gets e Sets e hashCode() e equals
}
H – Outras classe do pacote br.to.gov.modelo
H – InterfaceDAO.java pacote br.to.gov.DAO

Para facilitar a implementação dos métodos mais comuns na aplicação foi

elaborada a interfaceDAO.

package br.to.gov.DAO;

import java.util.List;

public interface InterfaceDAO<T> {

public void adicionar(T entidade);
public void alterar(T entidade);
public void deletar(T entidade);
public List<T>lista();
public T busca(Long codigo);
}
J – Classe DAO Genérico pacote e classe br.to.gov.DAO.classe

Essa classe é um ponto de acesso das DAO genéricas para manipulação de

dados junto ao banco de dados ela obrigatoriamente precisa receber uma
EntityManager no construtor para funcionar.

package br.to.gov.DAO;
import java.util.List;
import javax.persistence.EntityManager;

public class DAO<T> {

private final EntityManager em;
private final Class<T> classe;

//Construtor obrigatório para funcionar um DAO Genérico

public DAO(EntityManager em, Class<T> classe) {
super();
this.em = em;
this.classe = classe;
}
//O método recebe um Objeto do tipo T
public void adicionar(T t){
this.em.persist(t);
}
//Usado para remover um objeto
public void remove(T t){
this.em.remove(t);
}
//Busca por um parâmetro chamado id
public T busca(Long id){
return em.getReference(classe, id);
}
//Método para retorna uma lista de um objeto
//Ter cuidado com os espaços
@SuppressWarnings("unchecked")
public List<T> lista(){
return em.createQuery("select e from " + classe.getName() + "
e").getResultList();
}
public Class<T> getClasse() {
return classe;
}
//Método para alterar uma entidade
public void alterar(T t){
em.merge(t);
}
public EntityManager getEm() {
return em;
}
}
K – Classe DAO especifico para Internos pacote br.to.gov.DAO classe
InternoDAO.java
package br.to.gov.DAO;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import br.to.gov.modelo.Interno;

public class InternoDAO implements InterfaceDAO<Interno> {

private final DAO<Interno> dao;
private EntityManager em;
private Interno interno;

public InternoDAO(EntityManager em) {

dao = new DAO<Interno>(em, Interno.class);
setEm(em);
setInterno(new Interno());
}

public List<Interno> buscaPorApelido(String apelido){

List<Interno> resultado = null;
try{
Query consulta =
em.createNamedQuery(Interno.getBuscaporapelido());
consulta.setParameter("apelido", "%"+apelido+"%");
resultado = consulta.getResultList();
} catch(Exception e){
System.out.println("Nao deu -----------!"+e.getMessage());
}
return resultado;
}

public List<Interno> buscaPorNome(String nome){

List<Interno> resultado = null;
try{
Query consulta =
em.createNamedQuery(Interno.getBuscapornome());
consulta.setParameter("nome", "%"+nome+"%");
resultado = consulta.getResultList();
} catch(Exception e){
System.out.println("Nao deu -----------!"+e.getMessage());
}
return resultado;
}
@Override
public void adicionar(Interno t) {
dao.adicionar(t);
}
@Override
public void alterar(Interno t) {
dao.alterar(t);
}
@Override
public void deletar(Interno t) {
dao.remove(t);
}
 @Override
public List<Interno> lista() {
return dao.lista();
}
@Override
public Interno busca(Long codigo) {
return dao.busca(codigo);
}
//Gets e Sets
}
L – Classe DAO especifico para Unidade Prisional pacote br.to.gov.DAO classe
UnidadePrisionalDAO.java

package br.to.gov.DAO;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import br.to.gov.modelo.UnidadePrisional;

public class UnidadePrisionalDAO implements InterfaceDAO<UnidadePrisional> {

private final DAO<UnidadePrisional> dao;
private EntityManager em;
private UnidadePrisional unidadePrisional = new UnidadePrisional();

public UnidadePrisionalDAO(EntityManager em) {

dao = new DAO<UnidadePrisional>(em, UnidadePrisional.class);
setEm(em);
setUnidadePrisional(new UnidadePrisional());
}

public List<UnidadePrisional> buscaPorNome(String nome){

List<UnidadePrisional> resultado = null;
try{
Query consulta =
em.createNamedQuery(UnidadePrisional.buscaPorNome);
consulta.setParameter("nome", "%"+nome+"%");
resultado = consulta.getResultList();
} catch(Exception e){
System.out.println("Não deu -----------!"+e.getMessage());
}
return resultado;
}

@Override
public void adicionar(UnidadePrisional t) {
dao.adicionar(t);
}
@Override
public void alterar(UnidadePrisional t) {
dao.alterar(t);
}
@Override
public void deletar(UnidadePrisional t) {
dao.remove(t);
}
@Override
public List<UnidadePrisional> lista() {
return dao.lista();
}
@Override
public UnidadePrisional busca(Long codigo) {
return dao.busca(codigo);
}
//Gets e Sets
}
M – Classe DAO especifico para Agente pacote br.to.gov.DAO classe
AgenteDAO.java

package br.to.gov.DAO;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import br.to.gov.modelo.Agente;

public class AgenteDAO implements InterfaceDAO<Agente>{

private final DAO<Agente> dao;
private EntityManager em;
private Agente agente;

//Obrigatorio para funcionar

public AgenteDAO(EntityManager em){
dao = new DAO<Agente>(em, Agente.class);
setEntityManager(em);
setAgente(new Agente());
}

public List<Agente> buscaPorNome(String nome){

List<Agente> resultado = null;
try{
Query consulta = em.createNamedQuery(Agente.buscaPorNome);
consulta.setParameter("nome", "%"+nome+"%");
resultado = consulta.getResultList();
} catch(Exception e){
System.out.println("Não deu -----------!"+e.getMessage());
}
return resultado;
}
public List<Agente> buscaPorLogin(String login){
List<Agente> resultado = null;
try{
Query consulta = em.createNamedQuery(Agente.buscaPorLogin);
consulta.setParameter("login", "%"+login+"%");
resultado = consulta.getResultList();
} catch(Exception e){
System.out.println("Não deu -----------!"+e.getMessage());
}
return resultado;
}

@Override
public void adicionar(Agente t){
dao.adicionar(t);
}
@Override
public void alterar(Agente t){
dao.alterar(t);
}
@Override
public void deletar(Agente t){
dao.remove(t);
}
@Override
public List<Agente> lista(){
 return dao.lista();
}

@Override
public Agente busca(Long codigo) {
return dao.busca(codigo);
}
//Gets e Sets
}
N – Demais classes do pacote br.to.gov.DAO
O – EntityConverter.java esta no pacote br.to.gov.conversor

Para facilitar o trabalho de converter de objeto para String e vise versa,

optamos por acrescentar no projeto uma classe de terceira conforme abaixo.
package br.to.gov.conversor;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
import javax.faces.convert.FacesConverter;
import javax.persistence.EmbeddedId;
import javax.persistence.Id;

/**
* Converter para entidades JPA. Baseia-se nas anotações @Id e @EmbeddedId para
identificar o
* atributo que representa a identidade da entidade. Capaz de detectar as
anotações nas classes superiores.
*
* @author Flávio Henrique
* @version 1.0.3
* @since 05/10/2010
*/
@FacesConverter(value="entityConverter")
public class EntityConverter implements Converter {
public Object getAsObject(FacesContext ctx, UIComponent component,
String value) {
if (value != null) {
return component.getAttributes().get(value);
}
return null;
}

public String getAsString(FacesContext ctx, UIComponent component,

Object obj) {
if (obj != null && !"".equals(obj)) {
String id;
try {
id = this.getId(getClazz(ctx, component), obj);
if (id == null) {
id = "";
}
id = id.trim();
component.getAttributes().put(id,
getClazz(ctx, component).cast(obj));
return id;
} catch (SecurityException e) {
e.printStackTrace(); // seu log aqui
} catch (IllegalArgumentException e) {
e.printStackTrace(); // seu log aqui
} catch (NoSuchFieldException e) {
e.printStackTrace(); // seu log aqui
} catch (IllegalAccessException e) {
e.printStackTrace(); // seu log aqui
 }
}
return null;
}

private Class<?> getClazz(FacesContext facesContext, UIComponent component) {

return component.getValueExpression("value").getType(
facesContext.getELContext());
}

public String getId(Class<?> clazz, Object obj) throws SecurityException,

NoSuchFieldException, IllegalArgumentException,
IllegalAccessException {

List<Class<?>> hierarquiaDeClasses =
this.getHierarquiaDeClasses(clazz);

for (Class<?> classeDaHierarquia : hierarquiaDeClasses) {

for (Field field : classeDaHierarquia.getDeclaredFields()) {
if ((field.getAnnotation(Id.class)) != null
|| field.getAnnotation(EmbeddedId.class) !=
null) {
Field privateField = classeDaHierarquia
.getDeclaredField(field.getName());
privateField.setAccessible(true);
if (privateField.get(clazz.cast(obj)) != null) {

return (String) field.getType()

.cast(privateField.get(clazz.c
ast(obj)))
.toString();
}
}
}
}
return null;
}

public List<Class<?>> getHierarquiaDeClasses(Class<?> clazz) {

List<Class<?>> hierarquiaDeClasses = new ArrayList<Class<?>>();

Class<?> classeNaHierarquia = clazz;
while(classeNaHierarquia != Object.class) {
hierarquiaDeClasses.add(classeNaHierarquia);
classeNaHierarquia = classeNaHierarquia.getSuperclass();

}
return hierarquiaDeClasses;
}
}
P – Classes do pacote br.to.gov.beans - AdvogadoBean.java

package br.to.gov.beans;

import java.io.Serializable;
import java.util.Date;
import java.util.List;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.faces.context.FacesContext;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import br.to.gov.DAO.AdvogadoDAO;
import br.to.gov.modelo.Advogado;
import br.to.gov.util.JPAUtil;

@ManagedBean
@RequestScoped
public class AdvogadoBean implements Serializable {
private static final long serialVersionUID = 1L;

private final EntityManager em;

private Advogado advogado;
private AdvogadoDAO dao;
private List<Advogado> advogados;
private List<Advogado> advogadoPor;
FacesContext context = FacesContext.getCurrentInstance();
private Date data = new Date();

public AdvogadoBean() {
em = new JPAUtil().getEntityManager();
dao = new AdvogadoDAO(em);
advogado = new Advogado();
advogados = null;
}

public String buscaPorNome(){

try{
if(dao.buscaPorNome(advogado.getNome()) != null){
advogadoPor = dao.buscaPorNome(advogado.getNome());
}
} catch(Exception e){
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_ERROR,"Erro","Erro ao tentar busca no nome
Advogado"));
}
return "/consultas/resultadoAdvogados";
}

//Salvar e alterar
public void salvar(){
em.getTransaction().begin();
try{
advogado.setDataCadastro(data);
dao.alterar(advogado);
 context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_INFO,"Cadastrado","Advogado Cadastrado com
sucesso!" ));
em.getTransaction().commit();
}catch(PersistenceException e){
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_ERROR,"Ops","Advogado ja cadastrado!" ));
}finally{
if(em != null){
em.close();
}
}
}

public void alterar(){

em.getTransaction().begin();
dao.alterar(advogado);
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_INFO,"Alterado","Advogado Alterado com
sucesso!" ));
em.getTransaction().commit();
em.close();
}

public String alterarLink(){

return "/cadastros/cadastroAdvogado";
}

public String excluir(){

em.getTransaction().begin();
dao.deletar(advogado);
em.getTransaction().commit();
em.close();
return "/listagens/listaAdvogados?faces-redirect=true";
}

public void buscaPorCodigo(){

em.getTransaction().begin();
Long codigo = advogado.getCodigo();
dao.busca(codigo);
em.getTransaction().commit();
em.close();
}

public List<Advogado> getAdvogados() {

if(advogados == null){
em.getTransaction().begin();
advogados = dao.lista();
em.getTransaction().commit();
}
//em.close;
return advogados;
}
//Gets e Sets
}
Q – Classes do pacote br.to.gov.beans - InternoBean.java
package br.to.gov.beans;

import java.io.Serializable;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.faces.context.FacesContext;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;

import br.to.gov.DAO.InternoDAO;
import br.to.gov.modelo.Interno;
import br.to.gov.util.JPAUtil;

@ManagedBean
@RequestScoped
public class InternoBean implements Serializable {
private static final long serialVersionUID = 1L;

private Interno interno;

private EntityManager em;
private InternoDAO dao;
private List<Interno> internoPor;
private List<Interno> internos;
FacesContext context = FacesContext.getCurrentInstance();

public InternoBean() {
em = new JPAUtil().getEntityManager();
dao = new InternoDAO(em);
interno = new Interno();
internos = null;
}

public String buscaPorApelido(){

try{
if(dao.buscaPorApelido(interno.getApelido()) != null){
internoPor = dao.buscaPorApelido(interno.getApelido());
}
} catch(Exception e){
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_ERROR,"Erro","Erro ao tentar busca no Apelido
do Interno"));
}
return "/consultas/resultadoInternos";
}
public String buscaPorNome(){
try{
if(dao.buscaPorNome(interno.getNome()) != null){
internoPor = dao.buscaPorNome(interno.getNome());
}
} catch(Exception e){
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_ERROR,"Erro","Erro ao tentar busca no Apelido
do Interno"));
 }
return "/consultas/resultadoInternos";
}
//Salvar e alterar
public void salvar(){
em.getTransaction().begin();
try{
if(dao.getInterno().getCodigo() !=null){
dao.alterar(interno);
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_INFO,"Alterado","Interno Alterado com
Sucesso"));
}else{
dao.adicionar(interno);
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_INFO,"Cadastrado","Interno Cadastrado com
Sucesso"));
}
em.getTransaction().commit();
} catch(PersistenceException e){
context.addMessage(null, new
FacesMessage(FacesMessage.SEVERITY_ERROR,"Ops","Interno já cadastrado."));
} finally{
if(em != null){
em.close();
}
}
}

public String alterar(){

return "/cadastros/cadastroInterno";
}

public String excluir(){

em.getTransaction().begin();
dao.deletar(interno);
em.getTransaction().commit();
em.close();
return "/listagens/listaInternosDadoPessoais?faces-redirect=true";
}

public void buscaPorCodigo(){

em.getTransaction().begin();
Long codigo = interno.getCodigo();
dao.busca(codigo);
em.getTransaction().commit();
em.close();
}
//Gets e Sets
}
R – Demais classes do pacote br.to.gov.beans
S – Arquivos xhtml
T – Arquivos xhtml para cadastro de Agentes

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui"
xmlns:sec="http://www.springframework.org/security/facelets/tags">

<ui:composition template="/templates/template.xhtml">
<ui:define name="conteudo">
<h:form id="edicao">
<p:panel id="painel" toggleable="true">
<f:facet name="header">
<h:graphicImage library="imagens" name="agente.png" />
<h:outputText value="Cadastro/Alteração - Agentes"
styleClass="titulos"/>
</f:facet>
<p:growl id="msn" showDetail="true" sticky="true"
showSummary="false"/>
<h:panelGrid columns="2">
<h:outputLabel value="Código:" />
<p:inputText id="codigo" value="#{agenteBean.agente.codigo}"
readonly="true" size="20"/>
<h:outputLabel value="Nome:" />
<p:inputText id="nome" value="#{agenteBean.agente.nome}" size="40"
required="true" requiredMessage="Campo NOME Obrigatório"/>
<h:outputLabel value="Login:" />
<p:inputText id="username" value="#{agenteBean.agente.login}"
size="40" required="true" requiredMessage="Campo LOGIN Obrigatório">
<f:validateLength minimum="3" maximum="15"/>
</p:inputText>
<h:outputLabel value="Senha:" rendered="#{agenteBean.agente.nome ==
null}"/>
<p:password id="password" rendered="#{agenteBean.agente.nome ==
null}" value="#{agenteBean.agente.senha}" size="20" required="true"
requiredMessage="Campo SENHA Obrigatório">
<f:validateLength minimum="3" maximum="15"/>
</p:password>
<h:outputLabel value="Matricula:" />
<p:inputText id="matricula" value="#{agenteBean.agente.matricula}"
size="20" required="true" requiredMessage="Campo MATRICULA Obrigatório"/>
<h:outputLabel value="Telefone:" />
<p:inputMask mask="(99) 9999-9999" id="telefone"
value="#{agenteBean.agente.telefone}" size="20"/>
<h:outputLabel value="Celular:" />
<p:inputMask mask="(99) 9999-9999" id="celular"
value="#{agenteBean.agente.celular}" size="20"/>
<h:outputLabel value="Email:" />
<p:inputText id="email" value="#{agenteBean.agente.email}" size="40"
required="true" requiredMessage="Campo EMAIL Obrigatório">
<f:validateRegex pattern="[\w\.-]*[a-zA-Z0-9_]@[\w\.-]*[a-zA-Z0-9]\.
[a-zA-Z][a-zA-Z\.]*[a-zA-Z]" />
</p:inputText>
<h:outputText value="Lotação:" />
 <p:selectOneMenu id="lotacao" value="#{agenteBean.agente.lotacao}"
required="true" requiredMessage="O TIPO de unidade deve ser selecionado">

<f:selectItem itemLabel="Selecione a Lotação Atual do Agente"/>

<f:selectItems value="#{unidadePrisionalBean.unidadesPrisionais}"
var="lotacao" itemLabel="#{lotacao.nome}" itemValue="#{lotacao}"/>
<f:converter converterId="entityConverter"/>
</p:selectOneMenu>
<h:outputText value="Data Início Lotação" />
<p:calendar id="inicioLotacao"
value="#{agenteBean.agente.inicioLotacao}" navigator="true" pattern="dd/MM/yyyy"
locale="pt_BR" />
</h:panelGrid>
<f:facet name="footer">
<p:commandButton type="reset" value="Cancelar " />
<p:commandButton id="salvar" value="Salvar"
action="#{agenteBean.salvar}" update="msn"/>
<h:outputLink value="/Sisgespen/administrador/cadastroAgente.jsf">
<h:graphicImage library="imagens" name="adicionar.gif"
style="border:0"/>
</h:outputLink>
</f:facet>
</p:panel>
</h:form>
</ui:define>
</ui:composition>
</html>
U – Arquivos xhtml para listagem de Internos

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui"
xmlns:sec="http://www.springframework.org/security/facelets/tags">

<ui:composition template="/templates/template.xhtml">
<ui:define name="conteudo">
<h:form id="form">
<p:panel header="Lista de Agentes Cadastrados" toggleable="true">
<h:outputLink value="/Sisgespen/administrador/cadastroAgente.jsf">
<h:graphicImage library="imagens" name="adicionar.gif" style="border:0"/>
</h:outputLink>
<h:outputText value=" - " />
<h:commandLink>
<h:graphicImage library="imagens" name="pdf.png" title="Imprimir PDF"/>
<p:dataExporter type="pdf" target="ListaAgentes" fileName="agente"/>
</h:commandLink>

<p:dataTable id="ListaAgentes" rows="5" value="#{agenteBean.agentes}"

var="agente" paginator="true">
<p:column>
<f:facet name="header">Ativo?</f:facet>
<h:commandLink action="#{agenteBean.ativar}" onclick="if (!confirm('Confirma
a Ativação ou Desativação do Agente #{agente.nome}')) return false"
update="@form">
<h:graphicImage library="imagens" name="usuario_ativo_#{agente.ativo}.png"
/>
<f:setPropertyActionListener target="#{agenteBean.agente}"
value="#{agente}"/>
</h:commandLink>
</p:column>

<p:column>
<f:facet name="header">Nome</f:facet>
<h:outputText value="#{agente.nome}" />
</p:column>

<p:column>
<f:facet name="header">Matricula</f:facet>
<h:outputText value="#{agente.matricula}" />
</p:column>

<p:column>
<f:facet name="header">Login</f:facet>
<h:outputText value="#{agente.login}" />
</p:column>

<p:column>
<f:facet name="header">Telefone</f:facet>
<h:outputText value="#{agente.telefone}" />
</p:column>
 <p:column>
<f:facet name="header">Email</f:facet>
<h:outputText value="#{agente.email}" />
</p:column>

<p:column>
<f:facet name="header">Lotação Atual</f:facet>
<h:outputText value="#{agente.lotacao.nome}" />
</p:column>
<p:column>
<f:facet name="header">Senha</f:facet>
<h:outputText value="#{agente.senha}" />
</p:column>

<p:column>
<f:facet name="header">Data Início Lotação</f:facet>
<h:outputText value="#{agente.inicioLotacao}">
<f:convertDateTime showOn="button" pattern="dd/MM/yyyy" locale="pt_BR"/>
</h:outputText>
</p:column>

<p:column>
<f:facet name="header">Permissão no Sistema</f:facet>

</p:column>

<p:column>
<f:facet name="header">Editar</f:facet>
<p:commandLink action="#{agenteBean.alterar}">
<h:graphicImage library="imagens" name="Editar.png" style="border:0"/>
<f:setPropertyActionListener target="#{agenteBean.agente}"
value="#{agente}" />
</p:commandLink>
</p:column>

<sec:ifAnyGranted roles="ROLE_ADMINISTRADOR">

<p:column>
<f:facet name="header">Excluir</f:facet>
<p:commandLink action="#{agenteBean.excluir}" onclick="if (!
confirm('Confirma a exclusão do Agente #{agente.nome}')) return false"
update="@form">
<h:graphicImage library="imagens" name="excluir.gif" style="border:0"/>
<f:setPropertyActionListener target="#{agenteBean.agente}"
value="#{agente}" />
</p:commandLink>
</p:column>
</sec:ifAnyGranted>
</p:dataTable>
<h:commandLink>
<p:graphicImage library="imagens" name="pdf.png" title="Imprimir PDF"/>

</h:commandLink>
</p:panel>
</h:form>
</ui:define>
</ui:composition>
</html>
V – Arquivos xhtml para consultas de Internos

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui"
xmlns:sec="http://www.springframework.org/security/facelets/tags">

<ui:composition template="/templates/template.xhtml">
<ui:define name="conteudo">
<h:form id="formNome">
<p:panel header="Consulta Internos por nomes" toggleable="true">
<p:growl id="msn" showDetail="true" sticky="true" showSummary="false"/>
<p:panelGrid columns="2">
<h:outputText value="Digite o NOME do Interno" />
<p:inputText id="nome" value="#{internoBean.interno.nome}" size="40"
required="true" requiredMessage="Digite o Nome do Interno a ser procurado"/>

<p:commandButton type="reset" value="Cancelar " />

<p:commandButton value="Pesquisar " action="#{internoBean.buscaPorNome}"
update="formNome"/>
</p:panelGrid>
</p:panel>
</h:form>

<h:form id="formApelido">
<p:panel header="Consulta Interno por Apelido" toggleable="true">
<p:growl id="msn" showDetail="true" sticky="true" showSummary="false"/>
<p:panelGrid columns="2">
<h:outputText value="Digite o APELIDO do Interno" />
<p:inputText id="apelido" value="#{internoBean.interno.apelido}" size="40"
required="true" requiredMessage="Digite do Interno a ser procurado"/>

<p:commandButton type="reset" value="Cancelar " />

<p:commandButton value="Pesquisar " action="#{internoBean.buscaPorApelido}"
update="msn formApelido"/>
</p:panelGrid>
</p:panel>
</h:form>
</ui:define>
</ui:composition>
</html>
W – Arquivos xhtml para os menus

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui"
xmlns:sec="http://www.springframework.org/security/facelets/tags">

<h:head>
</h:head>
<h:body>
<p:menubar>
<p:menuitem id="principal" value="Principal" url="/publico/principal.jsf"
icon="/imagens/Editar.png"></p:menuitem>
<p:submenu label="Cadastros" icon="ui-icon-pencil">
<p:menuitem id="cadastroAgente" value="Cadastro Agentes"
url="/cadastros/cadastroAgente.jsf"/>
<p:menuitem id="cadastroTipoUnidade" value="Cadastro Tipo Unidade"
url="/cadastros/cadastroTipoUnidade.jsf"/>
<p:menuitem id="cadastroUnidade" value="Cadastro Unidade Prisional"
url="/cadastros/cadastroUnidadePrisional.jsf"/>
<p:menuitem id="cadastroPavilhaoPorUnidade" value="Cadastro Pavilhão por
Unidade" url="/cadastros/cadastroPavilhao.jsf"/>
<p:menuitem id="cadastroCelasPorPavilhao" value="Cadastro Celas por
Pavilhão" url="/cadastros/cadastroCelas.jsf"/>
<p:menuitem id="cadastroOcupacao" value="Cadastro Ocupações"
url="/cadastros/cadastroOcupacoes.jsf"/>
<p:menuitem id="cadastroInstrucao" value="Cadastro Graus de Instruções"
url="/cadastros/cadastroGrauInstrucao.jsf"/>
<p:menuitem id="cadastroEstadoCivil" value="Cadastro Estado Civil"
url="/cadastros/cadastroEstadoCivil.jsf"/>
<p:menuitem id="cadastroAdvogado" value="Cadastro Advogados"
url="/cadastros/cadastroAdvogado.jsf"/>
<p:menuitem id="cadastroInterno" value="Cadastro Internos"
url="/cadastros/cadastroInterno.jsf"/>
</p:submenu>
<p:submenu label="Listagens" icon="ui-icon-document">
<p:menuitem value="Listagem Agentes" url="/listagens/listaAgentes.jsf"/>
<p:menuitem value="Listagem Tipos de Unidades"
url="/listagens/listaTiposUnidades.jsf"/>
<p:menuitem value="Listagem Unidades Prisonais"
url="/listagens/listaUnidades.jsf"/>
<p:menuitem value="Listagem Pavilhoes por Unidades Prisonais"
url="/listagens/listaPavilhoesUnidades.jsf"/>
<p:menuitem value="Listagem Celas por Pavilhoes e Unidades Prisonais"
url="/listagens/listaCelasPavilhoesUnidades.jsf"/>
<p:menuitem value="Listagem Ocupações" url="/listagens/listaOcupacoes.jsf"/>
<p:menuitem value="Listagem Graus de Instruções"
url="/listagens/listaGrausInstrucoes.jsf"/>
<p:menuitem value="Listagem Estados Civis"
url="/listagens/listaEstadoCivil.jsf"/>
<p:menuitem value="Listagem Advogados" url="/listagens/listaAdvogados.jsf"/>
<p:menuitem value="Listagem Internos - Dados Pessoais"
url="/listagens/listaInternosDadoPessoais.jsf"/>
 <p:menuitem value="Listagem Internos - Dados Socioeconômicos"
url="/listagens/listaInternosDadoSocio.jsf"/>
</p:submenu>
<p:submenu label="Consultas" icon="ui-icon-search">
<p:menuitem value="Consultas de Agentes"
url="/consultas/consultaAgentes.jsf"/>
<p:menuitem value="Consultas de Internos"
url="/consultas/consultaInternos.jsf"/>
<p:menuitem value="Consultas de Advogados"
url="/consultas/consultaAdvogados.jsf"/>
<p:menuitem value="Consultas de Unidades Prisionais"
url="/consultas/consultaUnidadesPrisionais.jsf"/>
</p:submenu>
<p:submenu label="Relatórios" icon="ui-icon-gear">

</p:submenu>
<p:menuitem id="ajuda" value="Ajuda" url="/publico/ajuda.jsf" icon="ui-
icon-close" />
<p:menuitem id="sair" value="Sair" url="/publico/logout.jsf" icon="ui-icon-
close" />
</p:menubar>
</h:body>
</html>
X – Arquivos xhtml para o templade

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!-- Definição dos namespace -->
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:p="http://primefaces.org/ui"
xmlns:sec="http://www.springframework.org/security/facelets/tags">

<h:head>
<!-- Importação do arquivo de estilos -->
<h:outputStylesheet name="folha.css" library="css"></h:outputStylesheet>
<!-- Definição do titulo da aplicação, este também pode ser substuido para
cada pagina -->
<title>Sistema de Gestão Penitenciário</title>
</h:head>
<h:body>
<!-- Definição do div geral -->
<div id="geral">
<!-- Definições de um layout com um div geral e quatro internos, são
eles logo, topo, conteúdo e rodape -->
<div id="logo">
<ui:insert name="logo">
<h:graphicImage name="Sis-Gespen.png"
library="imagens"/><br />
<h:outputText value="Usuário Logado:
#{request.remoteUser}" />
</ui:insert>
</div>

<div id="topo">
<ui:include src="/publico/menu.xhtml"/>
</div>

<div id="conteudo">
<!-- Definição da parte a ser substituida as paginas -->
<ui:insert name="conteudo">Adicione aqui o conteudo</ui:insert>
</div>
<div style="clear: both;"></div>
<div id="rodape">
<ui:insert name="rodape">
<p:panel>Sistema de Gestão Penitenciário<br />Todos os
direitos reservados<br />Secretaria de Defesa Social</p:panel>
</ui:insert>
</div>
</div>
</h:body>
</html>
Y – Tela de cadastro dos Agentes

Ilustração 29 – Tela de cadastro dos Agente no SISGESPEN Fonte: Autor

Z – Tela de cadastro dos Internos

Ilustração 30 – Tela de cadastro dos Internos no SISGESPEN Fonte: Autor

AA – Tela de cadastro Unidade Prisional

Ilustração 31 – Tela de cadastro das Unidades Prisionais no SISGESPEN Fonte: Autor

AB – Tela de consulta de Agentes
Ilustração 32 – Tela de consulta de Agentes no SISGESPEN Fonte: Autor
AC – Tela de consulta de Internos
Ilustração 33 – Tela de consulta de Internos no SISGESPEN Fonte: Autor
AD – Tela de listagem de Agentes

Ilustração 34 – Tela de listagem de Agentes SISGESPEN Fonte: Autor

AE – Tela de listagem de Internos Dados Pessoais e Socioeconomicos
Ilustração 35 – Tela de listagem de Internos SISGESPEN Fonte: Autor
AF – Tela de listagem de Advogados

Ilustração 36 – Tela de listagem de Advogados SISGESPEN Fonte: Autor

AG – Tela de alteração de Advogados

Ilustração 37 – Tela de alteração de Advogados SISGESPEN Fonte: Autor