JSTL - Implementando um pool de conexões

Continuando com nossa série sobre JSTL, veremos nesse artigo, O que é? Como funciona? Como criar e como consumir um pool de conexões gerenciado pelo container TomCat  e  usado por nossa aplicação JSTL para acessar um servidor  de banco de dados Oracle.

A idéia desse recurso é bem simples, porém, seu uso traz grandes benefícios para o desempenho de nossas aplicações, no caso, neste artigo, focaremos na configuração de nosso arquivo de contexto, e no consumo desse pool através da tag dataSource do pacote SQL da tecnologia JSTL. 

O que é um pool de conexões?

Imagine a seguinte a situação: em uma aplicação sem um pool, caso você abra uma conexão com um banco de dados,  será criado um objeto do tipo Connection na memória,  esse objeto se comunicará com o  seu servidor de banco de dados, e este por sua vez, alocará recursos de instância de forma dedicada para aquela conexão, repetindo-se, cada vez que sua aplicação for iniciada por qualquer usuário(ver figura 01). Esse processo apesar de ser perfeitamente funcional e simples, pode implicar em um alto custo  de performance, caso sua aplicação tenha uma alta demanda de usuários e um grande tráfego de dados.

Figura 01 – Arquitetura de conexão sem pool

Um Pool de conexões almeja exatamente solucionar esse gargalo, pois através dessa técnica, cada sessão de nossa aplicação, consumirá  apenas uma conexão já existe com o banco de dados.

Na verdade, essa conexão vai ser criada somente uma vez pela primeira sessão que a consumi-la,  ou quando o servidor como o TomCat for iniciado, assumindo a responsabilidade de gerenciar o ciclo de vida da conexão em vigor e fornece-la da maneira mais dinâmica possível para as aplicações(ver figura 02). 

Figura 02 – Arquitetura de  conexão com pool gerenciado pelo TomCat

Configurando nosso pool de conexões

Como estamos tratando de uma aplicação web que será gerenciada pelo web container TomCat, é importante lembrar que é necessário que você já tenha alguma vivência com esse tipo de aplicações.

E como estaremos criando um exemplo usando a tecnologia JSTL, sobre uma página JSP, é importante que também já conheça seu funcionamento e as principais tags dessa dobradinha.

Lembrando que estamos usando o Oracle DataBase 9i para aplicar nosso exemplo, porém, sinta-se livre para usar essas técnicas com outro banco de dados de sua preferência ou necessidade.

Antes de continuarmos, você deve saber que, quando criamos uma aplicação  web  no padrão de diretórios Jakarta, teremos uma distribuição  dos arquivos e pastas de nosso projeto conforme mostrado na figura 03.

Figura 03 – Padrão Jakarta de estrutura de diretórios para aplicações web

Portanto, levando em consideração que seu projeto tenha uma estrutura semelhante ao mostrado na figura 03, vamos agora, configurar nosso arquivo context.xml, conforme a listagem 01, para que nossa aplicação, quando for iniciada pela primeira vez, disponibilize ao TomCat, o gerenciamento da conexão com o banco de dados, usando o conceito de recurso, conforme mostra tag  “resource” abaixo.

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

<Context path="/AppJSTL">

  <Resource

      auth="Container"

      driverClassName="oracle.jdbc.driver.OracleDriver"

      maxActive="20"

      maxIdle="10"

      maxWait="-1"

      name="jdbc/myoracle"

      type="javax.sql.DataSource"

      url="jdbc:oracle:thin:@172.20.0.50:1521:ORA920"

      username="sysdba"

      password="masterkey"   />

</Context>

Listagem 01 – Configuração do arquivo context.xml da pasta META-INF de sua aplicação

Lembrando que essa é uma das formas de configurar um pool de conexões, pois, podemos usar esse mesmo conjunto de tags XML, no arquivo server.xml, disponível na pasta “conf” do servidor TomCat.

Veja na tabela 01, o significado de cada atributo da tag resource, contida no arquivo context.xml.

Essa configuração de contexto irá criar uma conexão que ficará disponível no TomCat, agora é necessário que nossa aplicação referencie o pool através do arquivo web.xml, para que dessa forma, o nome JNDI seja disponibilizado para ser acessado por qualquer parte de nosso projeto. Observe a listagem 02, contendo a tag resource-ref que deverá ser adicionado no mesmo arquivo web.xml.

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

<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <session-config>

        <session-timeout>30</session-timeout>

    </session-config>

    <resource-ref>          

        <description>Oracle Datasource </description>

        <res-ref-name>jdbc/myoracle</res-ref-name>

        <res-type>javax.sql.DataSource</res-type>

        <res-auth>Container</res-auth>

    </resource-ref>

</web-app>

Listagem 02 – Configuração do arquivo web.xml da pasta WEB-INF de sua aplicação

Lembrando que, como é o TomCat, que efetua a conexão com o banco de dados,  é necessário colocar no diretório common\lib do TomCat, o jar com o driver JDBC do oracle, neste caso estamos usando o arquivo  ojdbc14.jar.

Agora vamos codificar nossa página JSP, usando as tags JSTL, para acessar o dataSource contendo o pool de conexões, note que esse exemplo, é semelhante ao do artigo “JSTL – Aplicações web simples e fácil em Java” (veja o link na parte de referências no final do artigo), tendo como grande diferença a forma como estamos usando a tag setDataSource, pois nesse exemplo abaixo, definimos nessa tag, que será usado pool de conexões conforme no nome JNDI do atributo dataSource. Veja na listagem 03, o conteúdo de nosso index.jsp, note que, os principais pontos do código estão devidamente comentados para seu melhor entendimento.

<%@page contentType="text/html"%>

<%@page pageEncoding="UTF-8"%>

<!--taglib é uma tag JSP para declaração dos pacotes específicos JSTL através da URI apropriada e da sugestão de prefixo padrão, lembrando que essa etapa é importante, pois, definirá o prefixo de chamada das tags de cada pacote.-->

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<%@taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>

<%@taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>

<html>

    <head>

               <!-- setDataSource é uma tag JSTL para configuração de acesso ao servidor de banco de dados criando um objeto dataSource que será consumido pelas outras tags SQL, que neste caso está referenciando o nome JNDI referente ao pool de conexões. -->

          <sql:setDataSource scope="session" var="ds" dataSource="jdbc/myoracle"/>

        <title>Exemplo JSTL - Manoel Pimentel </title>

    </head>

    <body>

        <h1>Listagem de Produtos</h1>

        <hr>

        <!--A tag query é usada para processar uma setença SQL de seleção de registros e gerar um objeto ResultSet internamente na memória, conforme especificado no atributo   var, usando a conexão aberta  chamada "ds", que neste caso está definido no atributo dataDource através do uso de EL(Expression Language). -->

        <sql:query var="ResultadoProdutos" dataSource="$">

            select * from PRODUTOS

        </sql:query>

        <table border="1">

            <thead>

                <th>Código</th>

                <th>Nome</th>

                <th>Ultima Compra</th>

                <th>Preco Custo</th>

                <th>Preco Venda</th>

                <th>Margem</th>

                <th>Avaliação</th>

            </thead>

            <!--forEach, implementa um laço  para fazer a interação no ResultSet  gerado pela tag query  conforme o atributo items.-->

            <c:forEach var="listaProdutos" items="${ResultadoProdutos.rows}">

                <tr>

                    <!--A tag out é responsável por gerar uma String de saída na tela -->

                    <td><c:out value="${listaProdutos.CODPRD}"/></td>

                    <td><c:out value="${listaProdutos.NOME}"/></td>

                    <!--formatDate aplica um padrão de formato, conforme o atributo pattern, em um valor tipo data definido no atributo value. -->

                   <td><fmt:formatDate pattern="dd/MM/yyyy" value="${listaProdutos.DATA_ULTIMA_COMPRA}"/></td>

                   <td><c:out value="${listaProdutos.PRECO_CUSTO}"/></td>

                   <td><c:out value="${listaProdutos.PRECO_VENDA}"/></td>

                    <!--A tag set declara e inicializa uma variável conforme o atributo value. -->

                    <c:set var="totalPrecoCusto" value="${totalPrecoCusto+listaProdutos.PRECO_CUSTO}"/>

                    <c:set var="totalPrecoVenda" value="${totalPrecoVenda+listaProdutos.PRECO_VENDA}"/>

                    <c:set var="valorMargem" value="${listaProdutos.PRECO_VENDA-listaProdutos.PRECO_CUSTO}"/>

                    <td><c:out value="$"/></td>

                    <!--As tags choose, when e otherwise,  aplicam um conjunto de  estrutura de decisão. -->

                    <c:choose>

                        <c:when test="${valorMargem<=350}">

                            <td>Baixa</td>       

                        </c:when>

                        <c:when test="${valorMargem<=400}">

                            <td>Media</td>       

                        </c:when>

                        <c:otherwise>

                            <td>Alta</td>

                        </c:otherwise>

                    </c:choose>

                </tr>

            </c:forEach>

            <tfoot>

                <th colspan="3">

                Total:

                </th>

                <th>

              <!--formatNumber aplica uma formatação de decimais no atributo value conforme o atributo pattern. -->

                    <fmt:formatNumber value="$" pattern="#,#00.00#"/>

                </th>

                <th>

                    <fmt:formatNumber value="$" pattern="#,#00.00#"/>

                </th>

            </tfoot>

        </table>

    </body>

</html> 

Listagem 03 – Código da página JSP index.jsp usando as tags JSTL.

Como os mostram os artigos anteriores, quando você rodar esse exemplo pelo TomCat, será exibida no navegador uma tabela(conforme a figura 04) contendo a listagem retornada pela consulta SQL e tratada pelas tags  JSTL.

Figura 04 – Tela web gerada por nossa página index.jsp.

Conclusões

Como você pode ver, esse exemplo é semelhante ao que já foi mostrado nos artigos anteriores, inclusive aproveitei a estrutura de código da página index.jsp, alterando apenas a definição da origem do dataSouce, que em nosso caso, está vindo agora de pool que está sendo gerenciado pelo web container TomCat,  portanto, espero que tenha aprendido como criar, configurar e usar um pool de conexões através das tags JSTL, e passe a beneficiar suas aplicações com a performance obtida com essa técnica. Obrigado e até próxima.

Referências:

http://java.sun.com/products/jsp/jstl/

Site da própria SUN sobre JSTL

https://www.devmedia.com.br/articles/viewcomp.asp?comp=3746

Artigo JSTL – Aplicações web simples e fácil em Java, que pode servir de base o entendimento  inicial de JSTL.

https://www.devmedia.com.br/articles/viewcomp.asp?comp=3929