Configurando Context-Params no Tomcat

    É comum uma aplicação precisar de parâmetros de contexto para algumas definições, e nesse artigo vou mostrar como fazer isso no Tomcat 7. Em outras versões pode mudar um pouco mas o princípio é o mesmo para criar os parâmetros e para lê-los.

    No Tomcat, a pasta conf tem dentro dela arquivos de configuração, entre eles o context.xml. Nesse arquivo criamos configurações como o DataSource e parâmetros que podem ser acessados pela aplicação.

    Nesse arquivo, podemos criar parâmetros de duas formas:
  

<Environment name="nomeEmpresa" value="Minha Empresa.com" type="java.lang.String" 

override="false"/>

    Ou: 

<Parameter name="nomeEmpresa" value="Minha Empresa.com" override="false"/> 

   
    A diferença entre elas é a forma de acesso pela aplicação. A primeira pode ser acessada via InitialContext do pacote javax.naming através de um lookup e a segunda via ServeletContext.

    Vamos ver o acesso ao parâmetro declarado como Environment:

InitialContext context = new InitialContext();
Context xmlNode = (Context) context.lookup("java:comp/env");
String nomeEmpresa = (String) xmlNode.lookup("nomeEmpresa");

    Agora vamos ver o acesso ao parâmetro declarado como Parameter:

String nomeEmpresa = request.getSession().getServletContext().getInitParameter("nomeEmpresa");

  Pronto, dessa forma você pode declarar quantos parâmetros precisar.


Fonte: https://stackoverflow.com/questions/41227888/i-want-to-read-the-parameters-of-tomcat-context-xml  

Inicializando e parando o Tomcat no Linux com o comando "service"

    Nesse post vou mostrar como configurar o Tomcat para ser inicializado e parado através do comando "service", e como colocar o servidor de aplicação para ser startado juntamente com a máquina.

    Vamos a configuração: Crie um arquivo em /etc/init.d/ chamado tomcat (não precisa de extensão) com o seguinte conteúdo:

#config tomcat
 
export CATALINA_HOME="/opt/apache-tomcat-7.0.69"

ERROR=0

case "$1" in
  start)
    echo $"Iniciando o Tomcat"
    sh $CATALINA_HOME/bin/startup.sh
    ;;

  stop)
    echo $"Parando servidor Tomcat"
        sh $CATALINA_HOME/bin/shutdown.sh
    ;;

  restart)
    echo $"Parando servidor Tomcat"
    sh $CATALINA_HOME/bin/shutdown.sh
    echo $"Iniciando servidor Tomcat"
    sh $CATALINA_HOME/bin/startup.sh
    ;;

  *)
    echo $"Uso: $0 {start|stop|restar}"

 exit 1
 ;;

esac

exit $ERROR

    Na parte destacada em amarelo, lembrar de colocar o caminho e versão do Tomcat do seu servidor. Agora vamos dar a permisão de leitura e execução:

chmod +rx /etc/init.d/tomcat

   Pronto, agora para inicializar o Tomcat bastausar o comando:

service tomcat start 

   

   E para parar:

service tomcat stop

   O restart por sua vez executa os dois comandos. Agora vamos configurar para iniciar o script no start do servidor. Basta executar este comando:

update-rc.d tomcat defaults

   Através deste comando é criado o link simbólico para a execução na inicialização do Linux. Para remover ele basta executar o seguinte:

update-rc.d tomcat remove

   Para esse post é só! Como sempre, espero ter ajudado...

 

Debug remoto no Tomcat com o Eclipse

    Nesse post vou mostrar como preparar o Tomcat para Debug remoto com o Eclipse.

    Primeiro precisamos criar um arquivo na pasta raiz do Tomcat, e esse arquivo muda de extensão e de conteúdo de acordo com o S.O..

    Vamos primeiro ao do Windows: pode chamá-lo de startupDebug.bat e o conteúdo básico deve ser o seguinte:

set JPDA_ADDRESS=8000
set JPDA_TRANSPORT=dt_socket
bin/catalina.bat jpda start

    No ambiente linux o arquivo pode ser chamado de startupDebug.sh e deve ter permissão de leitura e execução (+rx). O conteúdo básico é o seguinte:

export JPDA_ADDRESS=8000
export JPDA_TRANSPORT=dt_socket
bin/catalina.sh jpda start

    Feito isso, quando quisermos debugar o Tomcat pelo eclipse, basta executar o Tomcat a partir desse script, ao invés do startup.bat (ou startup.sh em ambientes Linux) que executamos de costume. A porta de acesso ao sistema via browser continua a mesma de antes, a nova porta configurada foi para o debug. Será necessário liberação da porta no firewall em caso de acesso a servidores protegidos.

    Tendo feito isso e com a aplicação já startada, vamos ao eclipse configurar o debug remoto.

    No eclipse, no menu Run vá em Debug Configurations, a seguinte janela abrirá:

    Clique com o botão direito do mouse na opção Remote Java Aplication e escolha a opção New Configuration.  A imagem abaixo mostra em realce cada ponto de configuração, que são bem intuitivos. Após escolher a aplicação e dizer o endereço da aplicação onde está o localhost, no campo Port coloque a porta que configuramos no arquivo e clieque em Debug.

    Pronto, se todas as configurações estiverem corretas, o eclipse vai se conectar com a aplicação e você poderá debugar normalmente o código. Abraços!

Criando DataSource no Tomcat 7 e usando com persistence.xml e/ou hibernate.cfg.xml

     Quando criamos uma aplicação, é comum termos ambientes diferentes e/ou clientes diferentes, e isso nos traz a necessidade de fazer a nossa aplicação se conectar com bases de dados diferentes para cada ambiente/cliente. Para resolver isso de forma elegante, tiramos a responsabilidade de conhecer a URL, Usuário e Senha do Banco da aplicação e passamos para o servidor. Nesse post mostro como montar o DataSource no Tomcat. (Foi feito no Tomcat 7 que é o que uso no trabalho).

1 - Copiar as libs referentes ao Driver JDBC e c3p0 para o TomCat

Ex:

- Driver JDBC

postgresql-8.4-702.jdbc3.jar

-Lib c3p0

c3p0-0.9.1.jar

- Dependências da lib c3p0

antlr-2.7.6.jar

commons-collections-3.2.jar

dom4j-1.6.1.jar

jta-1.0.1B.jar

2 - Adicione o seguinte trecho ao arquivo web.xml (Note que o <res-ref-name> contém o mesmo nome que vamos dar a configuração do DataSource no Tomcat)

<resource-ref>

<description>DB Connection</description>

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

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

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

</resource-ref>

Para quem usa hibernate.cfg.xml

3 - No hibernate.cfg.xml remova as informações de conexão (url, usuário e senha) e de pool, e acrescente apenas a seguinte linha:

<property name="hibernate.connection.datasource">java:/comp/env/jdbc/nome_datasource</property>

Para quem usa JPA

4 - No persistence.xml remova as informações de conexão (url, usuário e senha) e de pool, e acrescente apenas a seguinte linha:

<non-jta-data-source>java:comp/env/jdbc/nome_datasource</non-jta-data-source>

5 - Configurar o context.xml (apache-tomcat-7.0.96/conf/context.xml) do Tomcat adicionando o trecho de código abaixo

(Alterando endereço, senha e usuário do banco de acordo com o ambiente/cliente que o Tomcat está alocado)

<Resource name="jdbc/nome_datasource" auth="Container"

factory="org.apache.naming.factory.BeanFactory"

type="com.mchange.v2.c3p0.ComboPooledDataSource"

driverClass="org.postgresql.Driver"

jdbcUrl="jdbc:postgresql://x.x.x.x:5432/nome_banco"

user="usuario_bd"

password="senha_bd"

minPoolSize="10"

maxPoolSize="160" />

Fonte:

https://tomcat.apache.org/tomcat-7.0-doc/jndi-datasource-examples-howto.html

https://imasters.com.br/back-end/usando-jndi-com-hibernate

https://www.youtube.com/watch?v=6sD80FwmM6o
https://www.mchange.com/projects/c3p0/#configuration_properties

Passando argumentos para a JVM usando a IDE Eclipse e o Tomcat

    Nesse artigo vou mostrar como pasar para parametros para JVM como a quantidade mínima e máxima de memória que deve ser alocada e outros parâmetros que sejam necessários.
   
    Na aba Servers do eclipse, já com o Tomcat adicionado, clique duas vezes sobre o servidor desejado, isso irá abrir o overview do servidor, uma janela de "visão geral".

    Nessa tela, em General Information você encontra a opção open launch configuration,  clicando nela, será aberta a tela de configuração:

    Vá para a aba Arguments e passe os argumentos que você precisa no campo VM Arguments:

  
    Pronto, coloque os argumentos que deseja, aplique e clique em ok!