Ubuntu: Como configurar um teclado padrão americano p/ aceitar acentos pt_BR

Para voce que tem um computador com teclado americano como eu mas gostaria de usar acentos e “ç”.

Muito fácil no Ubuntu 8.10:

Sistema -> Preferencias -> Teclado.

Na aba “Disposições”, clique em um botão com um “+” para adicionar uma nova disposição.

Abrirá um nova Janela,

* Onde tem paíz coloque: “Estados Unidos”

* E onde tem variante coloque: “EUA Internacional (com teclas acentuavéis)”

Pronto, remova a desposição que existia, selecione a que foi criada como “padrão”. E clique em “Aplicar (Todo o sistema)”

OBS.: Para digitar o “ç” digite o acento agundo + “c” . (é como se você quisesse acentuar o “c”)

Para digitar qualquer acento sozinho. Precione a tecla do acento + “barra de espaço”

Instalando Java no Ubuntu (Linux)

O Java pode ser instalado de varias maneiras. Atravez do gerenciador de pacotes Synaptic, atraves de comando apt-get

sudo apt-get install sun-java6-jre
sudo apt-get install sun-java5-jdk

ou manualmente, que e como eu prefiro.

Os passos mostrados aqui sao para a instalacao manual do Java no seu Ubuntu.

Entre no site da sun e baixa a ultima versao do Java:   http://java.sun.com/javase/downloads/index.jsp

La basicamente voce vai encontrar duas “versoes”  do Java. O JRE (+- 20 MB) e JSDK (+- 80MB). Para quem quer apenas executar aplicacoes Java, a JRE eh suficiente. O JSDK ou qualquer outra coisa que o site contenha geralmente eh para quem esta interresado em desenvolver alguma aplicacao em Java.

Baixe o arquivo binario. “.bin” em um diretorio de sua preferencia – aqui eu vou usar o /usr/local/java

Se esse diretorio nao existir voce pode cria-lo:

$ sudo mkdir /usr/local/java

De permissao de execucao para o arquivo e o execute:

$ cd /usr/local/java
$ sudo chmod +x jdk-1_6_0_11-linux-i586.bin
$ sudo ./ jdk-1_6_0_11-linux-i586.bin

Para finalizar a instalacao, so eh preciso agora criar um variavel de ambiente “apontando” para o diretorio onde o Java foi instalado para que o sistema operacional seja capaz de acha-lo.

Abra o arquivo /etc/bashrc:

$ sudo gedit /etc/bash.bashrc

Acrescente as seguintes linhas ao final do arquivo:

JAVA_HOME=/usr/local/java/jdk1.6.0_11
export PATH=:$JAVA_HOME/bin:$PATH

Proto aplicacoes Java ja podem ser executadas na sua maquina.

OBS.: Caso possua mais de uma versao do Java na sua maquina (algumas versao do linux vem com uma implementacao do Java livre sem ser a implementacao da propria SUN), use o seguinte comando para escolhe a que voce acabou de instalar.

sudo update-alternatives – - config java

O sistema irá prover algumas opções, digite o número correspondente a opcao que monstra o diretorio onde voce acabou de instalar o Java, nesse caso o /usr/local/java

• Uma coisa importante que ninguem fala. A instalacao seja do JRE ou do JSDK nao instala o plugin do Java, que eh necessario para rodar applets Java dentro do seu navegador da internet – muito usado em sites de bancos, geralmente aqueles techados virtuais de seguranca.

Para instalar o pluing basta copiar ou criar um link simbolido  do arquivo .so que vem dentro do diretorio plugin do jre -para quem instalou o jsdk como eu o diretorio da jre vai esta dentro do diretorio do jsdk – para o diretorio plugins do firefox (no meu caso eu estava usando o firefox)

O comando abaixo cria esse link simbolico. É só trocar o caminho para o caminho onde está instalado o Java e o Firefox no seu sistema.

sudo ln -s /usr/local/java/jdk1.6.0_11/jre/plugin/i386/ns7/libjavaplugin_oji.so        /usr/lib/mozilla/plugins/

• Outra dica muito importante é para conseguir executar aplicações Java gráficas. Por exemplo, se você tentar executar o Eclipse pelo terminal vai funcionar, mas de der dois cliques para executar o Eclipse graficamente, ele não consiguirá encontrar a JVM apesar dela ter acabado de ter sido instalada. Será mostrado a seguinte mensagem:

A Java Runtime Environment (JRE) or Java Development Kit (JDK)
must be available in order to run Eclipse. No Java virtual machine
was found after searching the following locations:
/home/username/eclipse/jre/bin/java
'java' in your current PATH

Para resolver esse problema crie um link simbólico do diretório “java” da JRE para o diretório /usr/bin. Para minha instalação ficou:

sudo ln -s /usr/local/java/jdk1.6.0_11/jre/bin/java         /usr/bin/java

Pronto, agoro acredito que tudo que seja relacionado a Java você consiga executar no Ubuntu ou qualquer outro Linux. Tando no terminal, quanto no modo gráfico ou no seu navegador da Web.

Criando arquivos JAR, WAR e EAR

Esses três arquivos são os arquivos mais utilizados para distribuição de aplicações Java. Existem várias maneiras de se gerar esses arquivos, algumas IDEs Java como o NetBeans já faz tudo automático para você. Mas eu gosto de criar projetos básicos e gerar “na mão” os arquivos para ficar menos dependente da IDE, vai que de repente surge a necessidade de mudar de NetBeans para Eclipse ou vice-versa. Você pode criar seu projeto na estrutura que quiser dentro das IDEs, desde que final gere os arquivos na estrutura definida nesse artigo para a districuiçao das suas aplicacões.

Um arquivo JAR é apenas um arquivo compactado (igual a um arquivo.zip) que contém um diretório de configurações chamado META-INF com um arquivo MANIFEST.MF dentro dele.

|-META-INF

|        | – MANIFEST.MF

|- DIRETORIO_1

|         |- *.class

|- DIRETORIO_N

Segue um script ANT, que deve ficar na raiz do seu projeto, e que gera um arquivo nessa estrutura:

<?xml version="1.0" encoding="UTF-8"?>
<project name="Criando arquivo EAR " basedir="." default="init">

<!-- definindo as propriedades do arquivo JAR -->
<property name="src" value="src"/>
<property name="bin" value="bin"/>
<property name="libs" value="libs"/>
<property name="dist" value="dist"/>
<property name="jar.file" value="${dist}/exemplo.jar" />

<!-- definindo onde estao os JARs dos sistema para a compilacao -->
<path id="classpath.base">
<fileset dir="${libs}">
<include name="*.jar" />
</fileset>
</path>

<target name="init">
<echo>Iniciando build do arquivo JAR com Ant</echo>
</target>

<target name="clean" depends="init">
<delete dir="${bin}"></delete>
</target>

<target name="prepare" depends="init">
<mkdir dir="${bin}" />
</target>

<!-- compilando os .java do diretorio src -->
<target name="compile" depends="init, clean, prepare">
<echo>Compilando as classes do diretorio src</echo>
<javac srcdir="${src}" destdir="${bin}" verbose="false">
<classpath refid="classpath.base" />
</javac>
</target>

<!--cria o JAR  -->
<target name="criar JAR " depends="compile">
<echo>Gerando arquivo JAR  </echo>
<jar jarfile="${jar.file}">
<fileset dir="${bin}">
</fileset>
</jar>
</target>

</project>

Os arquivos WAR seguem a mesma linha de raciocínio, mas tem a estrutura um pouco mais complexa
por causa do diretório WEB-INF, onde estão as “informações” do módulo web. Qualquer arquivo na
estrutura que se segue pode ser “deployado” em um servidor de aplicação web java.

|-META-INF

|        | – MANIFEST.MF

| – WEB-INF

|         | – classes

|         |          |- pacotes.*.class

|         | – lib

|         |          |- *.jar

|         | – web.xml

|

|- DIRETORIO_1

|         |- *.jsp

|- DIRETORIO_N

|- index.jsp

|-index.html

Abaixo um script ANT para gerar um arquivo WAR:

<?xml version="1.0" encoding="UTF-8"?>
<project name="Criacao do arquivo WAR" basedir="." default="deploywar">

    <!-- definicao das propriedades dos arquivos -->
<property name="src" value="src"/>
<property name="bin" value="bin" />
<property name="libs" value="libs" />
<property name="warfile.name" value="dist/exemplo.war"/>
<property name="webappdir" value="web pages" />
<property name="webxml.file" value="${webappdir}/WEB-INF/web.xml"/>
<property name="webinf.dir" value="${webappdir}/WEB-INF" />
<property name="deploy.home" value="/home/.../jboss/server/default/deploy"/>

	<!-- definindo onde estao os JARs dos sistema -->
<path id="classpath.base">
		<fileset dir="${libs}">
			<include name="*.jar" />
		</fileset>
	</path>

	<target name="init">
		<echo>Iniciando build web do projeto</echo>
	</target>

	<target name="clean" depends="init">
		<delete dir="${bin}"/>
	</target>

	<target name="prepare" depends="init">
		<mkdir dir="${bin}" />
	</target>

	<target name="compile" depends="init, clean, prepare">
		<echo>Compilando classes</echo>
		<javac srcdir="${src}" destdir="${bin}" verbose="false">
			<classpath refid="classpath.base" />
		</javac>
	</target>

	<!-- cria um arquivo war -->
	<target name="criaWar" depends="compile">
		<echo>Gerando arquivo WAR</echo>

		<war warfile="${warfile.name}" webxml="${webxml.file}">
			<fileset dir="${webappdir}" >
				<include name="*.html" />
				<include name="*.jsp" />
			</fileset>

			<classes dir="${bin}" />
	<lib dir="${libs}">
				<exclude name="alcuma_jar_desnecessario_ao_modulo_web.jar" />
			</lib>

			<webinf dir="${webinf.dir}">
       			<include name="${webxml.file}" />
     		</webinf>

		</war>

	</target>

	<!-- faz o deploy no JBoss -->
	<target name="deploywar" depends="criaWar">

		<echo>Deploy do JBOSS</echo>
		<copy file="${warfile.name}" todir="${deploy.home}" />
	</target>

</project>

Para finalizar os arquivos EAR. São arquivos que, para variar, possuem um diretório META-INF e
podem possuir vários arquivos JARs e WARs dentro dele. Cada um com a sua própria estrutura
já citadas anteriormente.
Seguem também o script ANT que gera um EAR:
</pre>
<?xml version="1.0" encoding="UTF-8"?>
<project name="Criando arquivo EAR " basedir="." default="init">

 <!-- definicao das propriedades dos arquivos -->
<property name="src" value="src"/>
<property name="webappdir" value="web pages"/>
<property name="bin" value="bin"/>
<property name="libs" value="libs"/>
<property name="dist" value="dist"/>
<property name="deploy.home" value="/home/.../jboss-4.2.0.GA/server/default/deploy"/>

 <!-- definindo as propriedades do modulo web-->
<property name="warfile.name" value="${dist}/exemplo.war" />
<property name="webxml.file" value="${webappdir}/WEB-INF/web.xml" />
<property name="webinf.dir" value="${webappdir}/WEB-INF" />

 <!-- definindo as propriedades do ear-->
<property name="metainf.dir" value="META-INF" />
<property name="session.jar.file" value="${dist}/exemplo.jar" />
<property name="application.ear.file" value="${dist}/exemplo.ear" />

 <!-- definindo onde estao os JARs dos sistema para a compilacao -->
<path id="classpath.base">
 <fileset dir="${libs}">
 <include name="*.jar" />
 </fileset>
 </path>

 <target name="init">
 <echo>Iniciando build do Projeto EAR com Ant</echo>
 </target>

 <target name="clean" depends="init">
 <delete dir="${bin}"></delete>
 </target>

 <target name="prepare" depends="init">
 <mkdir dir="${bin}" />
 </target>

 <!-- compilando os .java do diretorio src -->
 <target name="compile" depends="init, clean, prepare">
 <echo>Compilando as classes do diretorio src</echo>
 <javac srcdir="${src}" destdir="${bin}" verbose="false">
 <classpath refid="classpath.base" />
 </javac>
 </target>

 <!-- cria o arquivo war do ear -->
 <target name="criaWar" depends="compile">
 <echo>Gerando arquivo WAR</echo>

 <war warfile="${warfile.name}" webxml="${webxml.file}">

 <fileset dir="${webappdir}" >
 <include name="*.html" />
 <include name="*.jsp" />
 </fileset>

 <classes dir="${bin}">
 <!-- As classes Java desses diretorios -->
 <!-- nao fazem parte do modulo web -->
 <exclude name="session/**" />
 </classes>
	<lib dir="${libs}">
 <exclude name="jboss-ejb3x.jar" />
 </lib>

 <webinf dir="${webinf.dir}">
 <include name="${webxml.file}" />
 </webinf>

 </war>

 </target>

 <!--cria o JAR com os EJBs -->
 <target name="criar JAR EJB" depends="criaWar">
 <echo>Gerando arquivo JAR com EJB </echo>
 <jar jarfile="${session.jar.file}">
 <fileset dir="${bin}">
 <!-- Os beans do JSF nao estao no modulo EJB-->
 <exclude name="managedbean/**" />
 </fileset>
 </jar>
 </target>

 <!-- cria o arquivo EAR -->
 <target name="criar arquivo EAR" depends="criar JAR EJB">
 <echo>Gerando arquivo EAR </echo>
 <jar jarfile="${application.ear.file}">

 <metainf dir="META-INF">
 <include name="application.xml" />
 </metainf>

 <fileset dir="${dist}" includes="*.ejb3, *.jar, *.war, *.par" />
 </jar>

 <!-- se quiser apagar os arquivos gerados -->
 <!--
 <delete file="${warfile.name}"/>
 <delete file="${session.jar.file}"/>
 -->

 </target>

 <!-- faz o deploy no JBoss -->
 <target name="deploy-ear" depends="criar arquivo EAR, undeploy-ear">
 <echo>Deploy aplicacao no JBOSS</echo>
 <copy file="${application.ear.file}" todir="${deploy.home}" />
 </target>

 <!-- undeploy da aplicacao -->
 <target name="undeploy-ear">
 <echo>UnDeploy aplicacao no JBOSS</echo>
 <delete file="${deploy.home}/exemplo.ear"/>
 </target>

</project>
<pre>

Restringindo acesso e adicionando SLL a sua aplicação

Para restringir acesso a sua aplicação no Tomcat/JBoss basta colocar um arquivo chamado context.xml

no diretório WEB-INF da referida aplicação.

contextxml

O exemplo acima mostra as configuração para liberar acesso somente a localhost e à rede privada 10.0.0.0/24.

 

* Para colocar todas as páginas da suas aplicações para usar SSL basta apenas acrescentar o seguinte trecho ao arquivo web.xml (É preciso que o Tomcat/JBoss esteja configurado para usar SSL).

web.xml

 

 

Padrões de Projeto parte 6 de 6

         Finalmente, um exemplo simples que mostra a utilização de alguns dos padrões citados no trabalho e as conclusões.

Artigo Padroes de Projeto – Exemplo de Arquitetura e Conclusões

Padrões de Projeto parte 5 de 6

Padrões da camada de Aplicações e Apresentação: Facade, Command, MVC e Smart UI. 

Artigo Padroes de Projeto – Padroes de Aplicação e Apresentacao

Padrões de Projeto parte 4 de 6

Os padrões da camada de persistência: Data Mapper, Repositório e Active Record.

Artigo Padroes de Projeto – Padroes de Persistencia 

Padrões de Projeto parte 3 de 6

Terceira parte com os padrões da camada de modelo: Domain Model e DDD.

Artigo Padroes de Projeto – Padroes do Modelo

Padrões de Projeto parte 2 de 6

Esse é segunda parta do monografia com os padrões:

Delegation, Gateway, Layer SuperType, Separeted Interface, Template Method, Strategy, Factory, Plugin e Dependency Injection.

Artigo Padroes de Projeto – Padroes Basicos 

Padrões de Projeto parte 1 de 6

     Terminei o meu trabalho de final de curso da minha especialização em desenvolvimento de sistemas corporativos, então resolvi separar minha monografia em 6 artigos e disponibilizá-los aqui.

      O tema principal foi Padrões de Projetos e Domain Driven Design (DDD).

      Essa é a primeira parte, com a Introdução e falando sobre o Modelo de Desevolvimento de Sistemas em Camadas. 

       Artigo Padroes de Projeto – Introducao e Camadas