OpenShift e Spring MVC 3

Este artigo irá demonstrar passo-a-passo como criar uma aplicação utilizando o Framework Spring MVC 3 no servidor OpenShift.

Antes de iniciar este tutorial, é necessário que já tenha criado sua conta no openshift.redhat.com.

Vamos utilizar as seguintes ferramentas para nosso ambiente de desenvolvimento:

• Eclipse Juno EE  (http://www.eclipse.org/downloads/)
• JBossTools 4.0 (https://www.jboss.org/tools/download/dev/4_0)

1) Inicie o Eclipse e faça a instalação do Jboss Tools. Vá ao menu: Help > Install New Software …

• Clique em add…
• Selecione o arquivo zip que baixou do Jboss Tools
• Clique em next para prosseguir com a instalação, ate chegar na tela descrita abaixo:

Agora basta somente finalizar a instalação.

2) O próximo passo será criar uma chave RSA para fazer o deploy da aplicação de exemplo que iremos criar.

• Acesse o menu: Window > Preferences
• Com a janela de preferencias ainda aberta, acesse: General > Network Connection > SSH2
• Clique na aba Key Management e depois no botão Generate RSA Key … 
• Copie o código da chave
• Agora clique no botão Save Private Key, em seguida Ok conforme imagem abaixo:

3) Agora devemos colar a chave gerada pelo eclipse em sua conta do openShift.

• Acesse seu painel no site do openShift.
• Clique em My account e clique no botão Add a new Key conforme imagem:

4) Agora vamos iniciar a criação de nossa aplicação de exemplo com Spring Framework.

• Clique em: File > New Other > OpenShift Application conforme imagem abaixo:

5) Inserir usuário e senha de acesso após ter clicado em next:

6) Agora insira o nome da aplicação springmvc3 conforme a imagem:

7) Prossiga com a configuração de criação de um novo projeto:

8) Selecione o repositório local do git:

9) Agora basta finalizar a criação do projeto. Será criado uma estrutura conforme a imagem:

10) Acesse novamente seu painel no site do openShift e veja a aplicação de teste criada:

11) Agora acesse sua aplicação pela url que foi gerada, obtenha a seguinte tela:

12)  Vamos modificar o projeto de teste criado e em fim iniciar a criação de nossa aplicação uttilizando Spring Framework.

Delete os seguintes arquivos do projeto criado:

• health.jsp
• Diretório images
• index.html
• snoop.jsp
• faces-config.xml (em WEB-INF)

Confira a imagem com os arquivos mencionados que serão deletados:

13) Agora vamos deletar a servlet que está no arquivo web.xml (Delete somente o que está selecionado conforme imagem abaixo):

14) Vamos adicionar as dependências  do spring framework no pom.xml, a estrutura deve ficar assim:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>springmvc3</groupId>
 <artifactId>springmvc3</artifactId>
 <packaging>war</packaging>
 <version>1.0</version>
 <name>springmvc3</name>

<properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <maven.compiler.source>1.6</maven.compiler.source>
 <maven.compiler.target>1.6</maven.compiler.target>
 <spring.version>3.0.6.RELEASE</spring.version>
 </properties>

<dependencies>
 <!-- Jboss -->
 <dependency>
 <groupId>org.jboss.spec</groupId>
 <artifactId>jboss-javaee-6.0</artifactId>
 <version>1.0.0.Final</version>
 <type>pom</type>
 <scope>provided</scope>
 </dependency>

 <!-- Spring Framework -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-orm</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aop</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 <version>${spring.version}</version>
 </dependency>
 </dependencies>

<profiles>
 <profile>
 <!-- When built in OpenShift the 'openshift' profile will be used when
 invoking mvn. -->
 <!-- Use this profile for any OpenShift specific customization your app
 will need. -->
 <!-- By default that is to put the resulting archive into the 'deployments'
 folder. -->
 <!-- http://maven.apache.org/guides/mini/guide-building-for-different-environments.html -->
 <id>openshift</id>
 <build>
 <finalName>springmvc3</finalName>
 <plugins>
 <plugin>
 <artifactId>maven-war-plugin</artifactId>
 <version>2.1.1</version>
 <configuration>
 <outputDirectory>deployments</outputDirectory>
 <warName>ROOT</warName>
 </configuration>
 </plugin>
 </plugins>
 </build>
 </profile>
 </profiles>

 <!-- Repositories -->
 <repositories>
 <!-- Spring Releases -->
 <repository>
 <id>com.springsource.repository.bundles.release</id>
 <name>Spring Release Repository</name>
 <url>http://maven.springframework.org/release</url>
 </repository>
 <!-- Spring Milestones -->
 <repository>
 <id>spring-milestone</id>
 <name>Spring Framework Maven Milestone Repository</name>
 <url>http://maven.springframework.org/milestone</url>
 </repository>
 <!-- JBoss, Hibernate -->
 <repository>
 <id>jboss-public-repository-group</id>
 <name>JBoss Maven Repository</name>
 <url>https://repository.jboss.org/nexus/content/groups/public/</url>
 </repository>
 </repositories>
 <pluginRepositories>
 <pluginRepository>
 <id>com.springsource.repository.bundles.release</id>
 <name>Spring Release Repository</name>
 <url>http://maven.springframework.org/release</url>
 </pluginRepository>
 <pluginRepository>
 <id>com.springsource.repository.bundles.milestone</id>
 <name>Spring Milestone Repository</name>
 <url>http://maven.springframework.org/milestone</url>
 </pluginRepository>
 </pluginRepositories>
</project>

15) Agora que já adicionamos as dependências  necessárias do Spring, vamos configurar os arquivos xml’s para que o mecanismo do Spring funcione.

Abra seu arquivo web.xml e adicione o seguinte conteúdo:

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

<web-app version="3.0"
 xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 metadata-complete="false">

<!-- Declaracao do servlet do Spring MVC abaixo -->
 <servlet>
 <servlet-name>springmvc</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <init-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>
 /WEB-INF/spring-context.xml
 </param-value>
 </init-param>
 <load-on-startup>1</load-on-startup>
 </servlet>

<servlet-mapping>
 <servlet-name>springmvc</servlet-name>
 <url-pattern>/</url-pattern>
 </servlet-mapping>
</web-app>

Agora crie um arquivo chamado spring-context.xml em WEB-INF, adicione o seguinte conteúdo:

</pre>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd


http://www.springframework.org/schema/beans


http://www.springframework.org/schema/beans/spring-beans-3.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="br.com.app" />
 <mvc:annotation-driven />

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
 <property name="prefix" value="/WEB-INF/views/"/>
 <property name="suffix" value=".jsp"/>
 </bean>

</beans>

Crie um diretório chamado views em WEB-INF.

Agora crie uma página chamada hello.jsp dentro da pasta views que acabou de criar e insira o seguinte conteúdo:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>SpringMVC-3</title>
</head>
<body>
<h3>Olá Mundo com Spring MVC 3</h3>
<hr />
<tt>Teste com Spring MVC 3 realizado com sucesso !!!</tt>
<p><a href="index.jsp">Página inicial</a></p>
</body>
</html>

Crie uma página chamada index.jsp no diretório webapp com o seguinte conteúdo:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>SpringMVC-3</title>
</head>
<body>
<h3>Bem vindo a página inicial</h3>
<hr />
<tt>A finalidade deste projeto é testar o Spring MVC 3.</tt>
<p><a href="olaMundoSpring">Testar um @RequestMapping</a></p>
</body>
</html>

16) Vamos criar a classe controller que será responsável pelo redirecionamento de nossa requisição de teste com o Spring.

Crie um pacote chamado: br.com.app em Java Resources (src/main/java)

Crie uma classe chamada AppController no pacote criado e insira o seguinte conteúdo:

package br.com.app;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class AppController {

@RequestMapping("/olaMundoSpring")
public String execute(){
return "hello";
}

}

17) Nossa aplicação de teste com o spring está quase pronta.

Clique com o botão direito em cima do projeto, vá no menu Maven e clique em Update Project… (Esse passo é necessário para que todas as dependências do maven sejam baixadas). Em seguida clique novamente como botão direito em cima do projeto para ir na opção Team.

Agora vamos fazer o commit de nossas páginas e arquivos de configuração. (Não se esqueça de selecionar os arquivos que criou) confira a imagem:

Selecione os arquivos e insira a mensagem de log:

18) Agora vamos fazer o deploy de nosso projeto, siga os passos da imagem abaixo e clique em Finish (Botão direito no projeto > Team > Remote > Push):

19) Por fim, basta acessar novamente o link de seu projeto conforme o passo 11, terá como resultado a seguinte tela:

20) E para finalizar, faça o teste clicando no link para testar um requestMapping, será direcionado para seguinte tela:

Parabéns, seu projeto de teste com o spring MVC 3 foi hospedado no OpenShift com sucesso.

O intuito deste artigo é para demostrar passo a passo a criação de um projeto com o openShift, daqui em diante, pode melhorar o nosso exemplo ou até mesmo publicar outras aplicações. Acredito que consegui explicar o básico da estrutura e espero que tenham sucesso com os seus projetos com o OpenShift, um grande abraço a todos.

Você pode fazer o download da aplicação de exemplo clicando aqui.

About these ads