Roteiro resumido instalação do mySQL, Java e Apache Tomcat.

(por Fabrício Guedes Bissoli – fbissoli2002@yahoo.com.br)

março de 2005

1 – Instalando o mySQL:

O primeiro passo é fazer o download do mySQL em http://www.mysql.com e instalá-lo.

Não é necessário nenhuma configuração especial para o mySQL.
O mySQL existe em versão para o Windows e Linux.

Obs.: O PostgreSQL existe somente para o Linux, porém é possível utilizá-lo sob Windows
com o auxílio do software Cygwin (http://www.cygwin.com) e o servidor CygIPC
(http://www.neuro.gatech.edu/users/cwilson/cygutils).

Instale o banco de dados mySQL normalmente (http://www.mysql.com).

1- Iniciar o banco:
C:\mysql\bin\mysqld (inicializará o mySQL)
Obs.: Caso não funcione, experimente dar duplo clique sobre o ícone do mysqld.
Deverá “piscar” uma tela de prompt do DOS. Para saber se ele está sendo executado, vá
até meucomputador -> painel de controle -> sistema -> ferramentas administrativas ->
serviços e veja se ele aparece lá e está inicializado.

2- Logar como root:

C:\mysql\mysql -u root (o default é sem password, por isso deve ser alterado a seguir)

3- selecionar o banco ‘mysql’:

mysql> use mysql; (nesse caso mysql é um banco criado pelo próprio mysql)

4- Alterar senha de root:

mysql> update user set password=password(‘novasenha’) where user=’root’;
mysql> Flush privileges

5- sair:
mysql> exit

6- logar novamente como root:

c:\mysql\mysql -u root -p
Enter password: *********

7- listar todos os databases existentes:

mysql> show databases;

8- criar um novo banco:

mysql> create database db2;

9- criar uma tabela em db2:

mysql> CREATE TABLE `emailusuarios` (
`nome` VARCHAR (50),
‘email’ VARCHAR(50),
`contador` INT AUTO_INCREMENT, INDEX(`contador`));

10- listar todas as tabelas do banco atual:

mysql> show tables;

11- visualizar estrutura da tabela criada:

mysql> desc emailusuarios;

12- criar novo usuário com acesso total à tabela criada:

shell> mysql -u root mysql
mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
-> ON db2.emailusuarios
-> TO fulano@localhost
-> IDENTIFIED BY 'senha';
(o comando GRANT é extenso e é recomendável um maior aprofundamento)

13- "deslogar" o root:

mysql> exit;

14- logar o novo usuário:

c:\mysql\mysql -u fulano -p
Enter password: *****

15- inserir valor:

mysql> INSERT INTO db2.emailusuarios (nome, email) VALUES("Ze das Couve",
"ze@couve.com");

16- selecionar valor:

mysql> SELECT db2.emailusuarios.email WHERE db2.emailusuarios.nome LIKE
“%Couve%”

17- Atualizar valor:

mysql> UPDATE db2.emailusuarios SET email=”ze@couve.net” WHERE
email=”ze@couve.com”

18- Apagar linhas da tabela:

mysql> DELETE from db2.emailusuarios WHERE email=ze@couve.net
OBSERVAÇÕES:

1- O SQL utilizado (ítens 15 a 18) é genérico e bastante simplificado, recomeda-se

um aprofundamento nesse assunto.

2- Existem diversos aplicativos para facilitar a administração de bancos de dados,

sendo que pode-se citar como exemplos o PHPmyAdmin (que consta de um
conjunto de scripts PHP interagindo com o mySQL rodando sobre um servidor
WEB como o Apache) e o MySQL-Front (www.mysqlfront.de) , rodando no
ambiente Windows independente de servidor web (ambos gratuitos).

3- A escolha de um banco de dados é algo que depende de diversos fatores. O

mySQL e o PostgreSQL são soluções gratuitas e bastante interessantes, todavia
o Oracle é um banco mais robusto para grandes aplicações. Existem diversos
benchmarks pela Internet que comprovam a superior velocidade do mySQL,
mas o Oracle possui maior segurança na integridade dos dados. O PostgreSQL
estaria entre os dois no que diz respeito a segurança e velocidade. Diversos
benchmarks (e a explicação dos critérios utilizados) estão disponíveis no site do
próprio mySQL e em outros locais da Internet.
 2 – Instalando o Java da Sun:

Baixe a versão estável mais recente do Java JDK (http://java.sun.com).

Obs.: Não precisa ser a versão que vem o netBeans, mas é importante que seja JDK.

Instale normalmente.

Configure a variável de ambiente JAVA_HOME:

Nos Windows 2000 e XP, vá em meu computador -> painel de controle -> Sistema -
> Avançado -> variáveis de ambiente e insira uma nova variável de ambiente
chamada JAVA_HOME apontando para o diretório aonde vc instalou o Java.
Ex.: C:\Program Files\Java\jdk1.5.0_01
Nos Windows 9x e ME, edite o autoexec.bat e insira a linha:
SET JAVA_HOME= C:\Program Files\Java\jdk1.5.0_01

Obs.: Note que o caminho pode variar, dependendo da sua versão e/ou instalação!

Crie outra variável de ambiente chamada CLASSPATH, a qual deverá apontar para:
.; C:\Program Files\Java\jdk1.5.0_01

Obs.: Note que antes do ; tem um .

A outra variável de ambiente a ser editada (normalmente já existe) é o PATH. Caso
já exista, acrescente o caminho do diretório bin do seu Java da seguinte forma:

Em variáveis de ambiente, acrescentar ;C:\Program Files\Java\jdk1.5.0_01\bin

após o valor de PATH. (Win 2000/XP).
SET PATH=%PATH%; C:\Program Files\Java\jdk1.5.0_01\bin (Win 9x / ME).

Sobre drivers JDBC:

JDBC é um padrão de comunicação, definido pela Sun Microsystems e utilizado na

linguagem Java, permitindo uma aplicação cliente "conversar" ou "enxergar" uma
aplicação servidora, no caso um SGBD.
Para executar uma consulta SQL a um banco de dados desde um programa Java é preciso
que um driver, que estabelece os mecanismos internos para a tradução do programa cliente
(a aplicação) para o programa servidor (o gerenciador de banco de dados), esteja disponível
para o sistema de banco de dados a ser acessado.
A API JDBC, encontrada no pacote Java.sql, contém apenas algumas classes concretas.
Grande parte da API é distribuída como classes da interface neutras do banco de dados que
especificam o comportamento sem fornecer nenhuma implementação. As implementações
reais são fornecidas por outros revendedores.
Um sistema de banco de dados individual é acessado através de um driver JDBC específico
que implementa a interface Java.sql.Driver. Os drivers existem para praticamente todos os
sistemas RDBMS populares, contudo nem todos estão disponíveis gratuitamente. A Sun
reúne um driver de ponte JDBC-ODBC gratuito com o JDK para permitir acesso de às
fontes de dados ODBC padrões, como por exemplo um banco de dados Microsoft Access.
Porém a Sun adverte o uso do driver de ponte para qualquer coisa diferente do
desenvolvimento e de uma aplicação muito limitada. Os desenvolvedores de servlets em
particular devem observar esse aviso, porque qualquer problema na seção do código nativo
do driver de ponte JDBC-ODBC poderá paralisar o servidor inteiro e não apenas seus
servlets.
Existem quatro tipos de tecnologia para o desenvolvimento de um driver JDBC, cada uma
com um conjunto de características próprias que se aplicam para o desenvolvimento de um
determinado tipo de aplicação que necessite das características inerentes ao driver. As
tecnologias, ou tipos, são:

• Tipo 1 JDBC-ODBC: Trata-se, na verdade, de uma ponte entre a API do JDBC

com um driver de ODBC. Para cada máquina cliente onde a aplicação estiver
instalada será necessário a instalação do driver de ODBC. Por essa razão esse tipo
de driver é mais adequado em redes corporativas ou aplicações servidoras em 3
camadas cujo código seja escrito em Java.

• Tipo 2 Native-API partly Java technology-enabled driver: É semelhante aos do

Tipo 1, diferindo por usar métodos nativos e não um driver ODBC para acessar o
servidor. Deve-se observar, tal qual no tipo anterior, que os métodos nativos devem
residir na máquina onde a aplicação estiver instala.

• Tipo 3 Net-protocol fully Java technology-enabled: Utiliza uma tecnologia de 2

camadas, onde a API do JDBC acessa um servidor intermediário, na verdade uma
parte do próprio driver, que se encarrega do acesso ao SGBD. Tem a vantagem de
poder ser utilizado via Internet e em Intranets, devendo ser considerada a tecnologia
mais flexível pois a porção servidora do driver pode ser implementada para acessar
diversos SGBD's.

Tipo 4 Native-protocol fully Java technology-enabled: Este driver converte as

chamadas da tecnologia JDBC diretamente no padrão de rede utilizado pelo
protocolo do SGBD. Ou seja , a aplicação cliente pode acessar uma aplicação
servidora remotamente, sem nenhum tipo de intermediação.
O driver tipos 1 e 2 não são aconselháveis para aplicações que rodarão em rede pois exigem
instalações no respectivos clientes e, como uma applet será recebida automaticamente
através de um download, parece que a necessidade de algo pré existente ou pré instalado na
máquina cliente seja um paradoxo mal resolvido. Todavia aplicações servidoras podem
tirar diversos proveitos dessa tecnologia. Um exemplo claro desse proveito seria aplicações
que são executadas diretamente num servidor, como os servlets.
Já os drivers dos dois outros tipos podem acessar SGBD's remotos e são mais eficientes
sem apresentar nenhum tipo de paradoxo. Deve-se notar, contudo, que os drivers do tipo 3
são mais flexíveis que os demais pois muitos permitem alterar o SGBD sem que se altere o
código da aplicação cliente.
Em http://industry.java.sun.com/products/jdbc/drivers a Sun disponibilizou um mecanismo
de busca a todos os fabricantes de drivers JDBC cadastrados. No momento em que esse
texto foi escrito havia 176 drivers cadastrados.
O PostgreSQL e o mySQL possuem um driver do tipo 4 e também pode ser utilizado com
os do tipo 3 pois o acesso ao servidor pode ser executado via ODBC. Portanto, como
muitos drivers do tipo 3 utilizam a ODBC para o acesso local, ambos podem utilizar a
tecnologia em questão, não sendo essa solução recomendável para acessos remotos
intensos.
A API JDBC para o PostgreSQL está disponível em
http://jdbc.postgresql.org/download.html e a do mySQL em
http://www.mysql.com/products/connector-j/index.html . Os arquivos .JAR de cada API
deve ser inserido no diretório C:\Program Files\Java\jdk1.5.0_01\jre\lib\ext e deve-se editar
CLASSPATH novamente, acrescentando o caminho COMPLETO até a API.
Ex: .;C:\Program Files\Java\jdk1.5.0_01; C:\Program
Files\Java\jdk1.5.0_01\jre\lib\ext\mysql-connector-java-3.1.7-bin.jar
Obs.: Lembrando que tanto o caminho, versão do jdk e versão do mysql-connector podem
mudar.
Caso esteja utilizando outro banco de dados que não o mySQL, o procedimento é o mesmo,
mudando-se o caminho e o nome da API da ponte.
Neste ponto você já pode testar um programa Java “standalone” (independe de servidor
web). Compile-o e execute-o de qualquer diretório.
Busca.java

import java.sql.*;

public class Busca {

public static void main (String[] args) {
String dbUrl = "jdbc:mysql://localhost/db1";

String user="root";
String password="";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection c = DriverManager.getConnection(dbUrl, user,
password);
Statement s = c.createStatement();
ResultSet r = s.executeQuery("select * from teste");
while (r.next()) {
System.out.println( r.getString("codigo") + "," +
r.getString("nome"));
}
s.close();
} catch(Exception e) {
e.printStackTrace();
}
}
}

3 – Instalando o servidor web APACHE TOMCAT:

Baixe o Tomcat em sua última versão mais estável de:
http://jakarta.apache.org/site/downloads/downloads_tomcat.html
No caso de Windows, é aconselhável baixar o executável ao invés do zip por razões de
facilidade de instalação.
Ex.: jakarta-tomcat-5.5.8.exe
Baixe e instale normalmente.
Ele solicitará que seja indicada uma senha de administrador, cuidado para não esquece-la!
A porta 8080 é default. Só a altere se souber o que está fazendo!
Quando for solicitado o Java CLASSPATH, lembrar de inserir o driver JDBC.
Ex: C:\Program Files\Apache Software Foundation\Tomcat
5.5\bin\bootstrap.jar;C:\Program Files\Java\jdk1.5.0_01\jre\lib\ext\mysql-connector-java-
3.1.7-bin.jar . Caso tenha esquecido desse detalhe, vá no ícone no canto inferior direito
(Apache Tomcat, clique com o botão direito e selecione “configure...”. Na aba “Java”,
acrescente ; C:\Program Files\Java\jdk1.5.0_01\jre\lib\ext\mysql-connector-java-3.1.7-
bin.jar ao final da linha de “Java Classpath”.
Existem outras duas variáveis de ambiente a serem criadas/editadas:
ANT_HOME : C:\Program Files\Apache Software Foundation\Tomcat 5.5\bin
CATALINA_HOME : C:\Program Files\Apache Software Foundation\Tomcat 5.5

Se instalou a partir do exe, ele deverá ter criado ícones no “Iniciar” do Windows. Clique no
“monitor Tomcat” e um ícone deverá aparecer no canto inferior direito. Clique com o botão
direito e escolha “start service”. Aguarde o servidor ser inicializado.

Caso tenha instalado a partir do zip, deverá inicializá-lo manualmente a partir do prompt do
DOS, entrando no diretório aonde tenha instalado o tomcat \bin e digitar startup . Para
parar o serviço, digite shutdown .

Se tudo estiver correto, digite http://127.0.0.1:8080/ de seu navegador e observe o que

acontece. Vá até manager e entre com o login e senha que tiver criado e a seguir teste os
exemplos de servlets e JSP entando nos diretórios de exemplos.

Entre na pasta webapps localizada em

C:\Program Files\Apache Software Foundation\Tomcat 5.5 (de acordo com sua
instalação).

Faça uma cópia da pasta servlets-examples para lá mesmo e renomeie esta nova pasta para
teste.

Observe se ela não apareceu no manager (do browser), caso não tenha aparecido, dê um
reload no seu navegador.

Observe agora que poderá acessa-la através de http://127.0.0.1:8080/lixo/

Agora você poderá editar seus arquivos de servlets e coloca-los nessa pasta (e apagar os
arquivos existentes antigos dali).

IMPORTANTE:
1 - Edite o index.html livremente. Apague os demais HTMLs que estiverem nesse diretório
e que não vá utilizar.
2- Na pasta WEB-INF existe um arquivo chamado web.xml. Edite-o de maneira a conter o
nome de seus servlets. Siga o exemplo do HelloWorld que deverá estar ali, ou seja,
substitua o HelloWorld e seu caminho pelo caminho/nome de seu servlet. Não apague as
pastas “util , compressionFilters, filters e listeners” contidas no diretório classes, mas pode
apagar todos os demais arquivos. Essa pasta deverá conter apenas os referidos diretórios
além de suas classes (servlets).

O próximo passo é compilar o exemplo seguinte e testá-lo. Note que será necessário:

1 – Servidor de banco de dados inicializado.

2 – Banco de dados, tabela, campos e conteúdo previamente inseridos.
3 – Servidor web Apache Tomcat inicializado.

Para executar-se servlets é necessário ainda ter-se o arquivo servlet-api.jar no

CLASSPATH. Este arquivo está em C:\Program Files\Apache Software
Foundation\Tomcat 5.5\common\lib e deve ser copiado para C:\Program
Files\Java\jdk1.5.0_01\jre\lib\ext . Uma outra alternativa é acrescentar o C:\Program
Files\Apache Software Foundation\Tomcat 5.5\common\lib ao CLASSPATH.

A seguir é apresentado um exemplo de um código JAVA para um servlet que se conecta ao

banco mySQL e seleciona firstname e lastname de uma tabela users. Note que ele utiliza
um driver do tipo 4 (driver Java nativo) chamado MySQL Connector/J. Esse driver é
disponibilizado para download direto do fabricante (http://www.mysql.com) sob os termos
de utilização da LGPL (veja em http://www.mysql.com/products/connector-j/index.html
para maiores informações).
select .java :

import java.io.*;
import java.sql.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class select extends HttpServlet {

public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException,

IOException {
Connection con = null;
Statement stmt = null;
ResultSet rs = null;

res.setContentType("text/html");
PrintWriter out = res.getWriter();

try {

String DBHOST = "localhost";

String DBNAME = "db1";
String DBUSER = "root";
String DBPASS = "";

String DBDRIVER = "com.mysql.jdbc.Driver";

/*== setup database driver and connect ==*/
Class.forName(DBDRIVER);
String conurl = "jdbc:mysql://"+DBHOST+"/"+DBNAME;
con = DriverManager.getConnection(conurl,DBUSER,DBPASS);

/*== create sql query and execute ==*/

String sql = "SELECT firstname,lastname FROM users";

stmt = con.createStatement();
rs = stmt.executeQuery(sql);
/*== display results ==*/
while (rs.next()) {
out.println("Nome: " + rs.getString("firstname") + " " +
rs.getString("lastname") + "\n");
}

}
catch(ClassNotFoundException e) {
out.println("Couldn't load database driver: " + e.getMessage());
}
catch(SQLException e) {
out.println("SQLException caught: " + e.getMessage());
}
finally {
// sempre fechar a conexao.
try {
if (con != null) con.close();
}
catch (SQLException ignored) {}
}
}
}
 Para o caso de o banco de dados ser o PostgreSQL, bastaria que fossem alterados as
seguintes linhas:
String DBDRIVER = "org.postgresql.Driver";
/*== setup database driver and connect ==*/
Class.forName(DBDRIVER).newInstance();
String conurl = "jdbc:postgresql://"+DBHOST+"/"+DBNAME;
Connection db = DriverManager.getConnection(conurl,DBUSER,DBPASS);

Para um acesso por driver do tipo 1 (ponte JDBC-ODBC), as alterações ficariam como a seguir:

String DBDRIVER = "sun.jdbc.odbc.JdbcOdbcDriver";

/*== setup database driver and connect ==*/
Class.forName(DBDRIVER).newInstance();
String conurl = "jdbc:odbc://"+DBHOST+"/"+DBNAME;
Connection db = DriverManager.getConnection(conurl,DBUSER,DBPASS);

Esse tipo de conexão pode ser utilizado, por exemplo, para o acesso a um banco de dados Access, da
Microsoft.

É possível também o acesso a certos bancos (como o mySQL) via ODBC, bastando para isso instalar o driver
referente (http://www.mysql.com), todavia isso não é recomendável por questões de performance.

Por fim, uma conexão Oracle seria assim:

String DBDRIVER = "oracle.jdbc.driver.OracleDriver";

/*== setup database driver and connect ==*/
Class.forName(DBDRIVER).newInstance();
String conurl = "jdbc:oracle://"+DBHOST+"/"+DBNAME;
Connection db = DriverManager.getConnection(conurl,DBUSER,DBPASS);

Simples, não?