Tutorial: Hola Mundo: Capa de Persistencia

Hasta ahora se construyó una aplicación  básica para mostrar los conceptos básicos de Spring Framework.

En ésta entrada se mostrará la integración de la capa de persistencia, haciendo énfasis únicamente en la persistencia sin detalle de los conceptos ya mencionados.

Contenido

- Crear Proyecto
- Procedimiento Persistencia
- Conclusión

Crear Proyecto

En Eclipse Crear proyecto Dynamic Web Project.

Convertir el proyecto a Proyecto Maven.

Modificar el POM.XML: Las siguientes son las dependencias necesarias para completar el tutorial.

<dependencies>
    <!-- Spring -->
    <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-core</artifactId>
     <version>4.3.2.RELEASE</version>
 </dependency>
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-webmvc</artifactId>
     <version>4.3.2.RELEASE</version>
 </dependency>
 <!-- Servlet -->
 <dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <scope>provided</scope>
 </dependency>
 <!-- Hibernate -->  
 <dependency>
     <groupId>org.hibernate</groupId>
     <artifactId>hibernate-entitymanager</artifactId>
     <version>5.2.2.Final</version>
 </dependency>  
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-orm</artifactId>
     <version>4.3.2.RELEASE</version>
 </dependency>
 <!-- Oracle, instalado localmente en Archiva --> 
 <dependency>
   <groupId>com.oracle</groupId>
   <artifactId>ojdbc7</artifactId>
   <version>12.1.0.1</version>
 </dependency>  
</dependencies>

Dentro de las dependecias se incluye el módulo ORM (Object Relational Mapping) de Spring, y en EntityManager de Hibernate.

IMPORTANTE: La dependencia del JDBC de Oracle (ojdbc7) NO se encuentra en el repositorio central de Maven.
Es necesario descargarla del sitio de Oracle y adicionarla manualmente a Maven o como librería de la aplicación. Si se está haciendo uso de un gestor como Apache Archiva, simplemente se puede subir la libería a Archiva, asignarle un GAV y se podrá acceder normalmente desde el POM. Por ejemplo para el ejercicio se subió a Archiva con el siguiente GAV:

<!-- Oracle, instalado localmente en Archiva --> 
 <dependency>
   <groupId>com.oracle</groupId>
   <artifactId>ojdbc7</artifactId>
   <version>12.1.0.1</version>
 </dependency>

Crear una clase java para el controlador:Crear una clase básica con el siguiente contenido:

package pkg.sw.controller;

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

@Controller
@RequestMapping("/")
public class PersistenceController {

 @RequestMapping("/hello") 
 public ModelAndView viewDate () {    
  return new ModelAndView("hello");
 }

}

Crear JSP: Crear dos JSP uno inicial llamado index.jsp y otro dentro del directorio jsp: jsp/hello.jsp.

index.jsp

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Soluciones Web</title>
</head>
<body>
 <h1>Hola mundo - Capa Persistencia</h1>
 <a href="hello">Dar Click acá</a>
</body>
</html>

jsp/hello.jsp

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Soluciones Web</title>
</head>
<body>
 <h2>Respuesta desde el controlador Spr</h2> 
</body>
</html>

Crear los archivos de configuración de Spring que se mostraron en la entrada anterior y de la misma forma relacionarlos en el Web.xml.

• web.xml
• applicationContext.xml
• spring-servlet.xml

Probar la aplicación a éste punto: Al cargarla muestra el index.jsp a dar clic en el enlace muestra hello.jsp.

Servicio:

Ahora se creará el servicio con su interfaz. Se creará una operación que envíe un mensaje al JSP mediante la inyección en el controlador:

Interfaz servicio:

package pkg.sw.service;

public interface ProductService {

 public String getProducts();

}

Implementación Servicio:

package pkg.sw.service.impl;

import org.springframework.stereotype.Service;
import pkg.sw.service.ProductService;


@Service
public class ProductServiceImpl implements ProductService{

 public ProductServiceImpl() {}
 
 public String getProducts()
 {
  return "Product1 <br/> Product2 <br/> Product3";
 }

}

Modificar Controlador:

package pkg.sw.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import pkg.sw.service.ProductService;

@Controller
@RequestMapping("/")
public class PersistenceController {

 @Autowired
 private ProductService productService;
 
 @RequestMapping("/hello") 
 public ModelAndView viewDate () {  
  
 return new ModelAndView("hello", 
                   "listProducts", productService.getProducts());
 }

}

Mostrar la variable enviada en el modelo desde en controlador en el JSP:

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Soluciones Web</title>
</head>
<body>
 <h2>Respuesta desde el controlador Spr</h2> 
 <div>${listProducts}</div>
</body>
</html>

IMPORTANTE: Para efectos de éste ejercicio, con el fin de mostrar fácilmente el resultado, se envía dentro de la cadena las etiquetas BR de salto de línea, en vez de hacerlos con un objeto y con JSTL o AngularJS, pero en aplicaciones reales no es recomendable ésta práctica.

Probar la aplicación a éste punto:

Procedimiento Persistencia:
A éste punto se ha repasado lo construido en el tutorial anterior, a partir de ahora se inicia la construcción y configuración de la capa de persistencia.

Con el ejercicio se pretende mostrar la configuración necesaria para Hibernate, y no se tiene en cuenta el paso de parámetros, simplemente se manejarán cadenas de texto (String). Tampoco se tiene en cuenta el flujo de excepciones/validaciones para efectos del ejercicio.

Configuración:
Configuración del archivo applicationContext.xml: Este archivo es de configuración de la aplicación y se adicionará la configuración de persistencia de Hibernate, se recomienda separar en un archivo exclusivo, pero para éste ejercicio se manejará sobre el mismo archivo. Se adiciona también a la cabecera los esquemas necesarios.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:jee="http://www.springframework.org/schema/jee"
 xsi:schemaLocation="
        http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/jee 
        http://www.springframework.org/schema/jee/spring-jee.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">        
   
    <!-- enabling annotation driven configuration /-->
    <context:annotation-config/>
 
  <!-- DataSource -->
  <jee:jndi-lookup id="dataSource" jndi-name="jdbc/SWTEST"/>  
    
 <!-- EntityManager -->
 <bean id="myEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
   <property name="dataSource" ref="dataSource" />
   <property name="packagesToScan" value="pkg.sw.repository" />
   <property name="jpaVendorAdapter">
         <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
      </property>
      <property name="jpaProperties">
         <props>            
            <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>                       
         </props>
      </property>      
   </bean>
   
   <!-- Transaction Manager -->
   <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
      <property name="entityManagerFactory" ref="myEmf" />
   </bean>
   
   <tx:annotation-driven />  
   
<!-- Exception translation bean post processor -->
   <bean id="persistenceExceptionTranslationPostProcessor"
      class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" /> 
    
    <!-- Scans the classpath of this application for @Components to deploy as beans -->
    <context:component-scan base-package="pkg.sw.repository" />
    <context:component-scan base-package="pkg.sw.service" />

</beans>

En el archivo se ha creado:

• El Data Source por JNDI. Significa que la administración de la conexión a la base de datos se le delegó al servidor de aplicaciones Weblogic Server. Por lo tanto se debe crear previamente el DataSource 'jdbc/SWTEST' en Weblogic.

  <jee:jndi-lookup id="dataSource" jndi-name="jdbc/SWTEST"/>
  

  
  
  
  NOTA: Si se desea también se puede hacer la conexión manualmente desde la aplicación así:
  

  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
         <property name="url" value="jdbc:oracle:thin:@10.85.84.142:1521:DSFSPE" />
         <property name="username" value="user" />
         <property name="password" value="pass" />
   </bean>
  

• La definición del EntityManager. 
  Hibernate SessionFactory vs. EntityManagerFactory
  Es preferible EntityManagerFactory y EntityManager porque están definidos por el estándar JPA. SessionFactory y Session son específicos de Hibernate. El EntityManager invoca Session de Hibernate internamente.
  

  <!-- EntityManager -->
      <bean id="myEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="pkg.sw.repository" />
        <property name="jpaVendorAdapter">
           <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
        </property>
        <property name="jpaProperties">
           <props>            
              <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>                       
           </props>
        </property>      
     </bean>
  

  
  
  Donde se referencia al datasource creado, se especifican los paquetes a escanear, y se configura Hibernate, en este caso el dialecto para la base de datos Oracle.

• Configuración del Transacción Manager. Donde se referencia el Bean del Entity Manager creado.
  

  <!-- Transaction Manager -->
     <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="myEmf" />
     </bean>

• Habilitar Transacción Manager y anotaciones @Transactional.
  

  <tx:annotation-driven />

• Finalmente el bean que actúa como traductor de manejo de excepciones para los beans que tengan la anotación @Repository.
  (http://docs.spring.io/spring/docs/current/spring-framework-reference/html/orm.html )
  

  <!-- Exception translation bean post processor -->
  <bean id="persistenceExceptionTranslationPostProcessor"
  class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
  

Weblogic.xml: Para evitar problemas de compatibilidad de las librerías existentes en Weblogic vs las librerías incluidas en el POM.XML se indicará en el archivo weblogic.xml de la aplicación preferencia a las librerías del WEB-INF:

<?xml version="1.0" encoding="UTF-8"?>
<wls:weblogic-web-app xmlns:wls="http://xmlns.oracle.com/weblogic/weblogic-web-app" 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 http://xmlns.oracle.com/weblogic/weblogic-web-app http://xmlns.oracle.com/weblogic/weblogic-web-app/1.8/weblogic-web-app.xsd">
<wls:weblogic-version>12.2.1</wls:weblogic-version>
<wls:context-root>SWHelloWorlPersistence</wls:context-root>
    
<wls:container-descriptor>
    <wls:prefer-web-inf-classes>true</wls:prefer-web-inf-classes>
</wls:container-descriptor>
    
</wls:weblogic-web-app>

Se pone a TRUE el tag prefer-web-inf-classes, lo que hará que las clases ubicadas en el directorio WEB-INF de la aplicación Web, se carguen con preferencia sobre las clases cargadas en el contenedor.
Crear entidad: Se crea una entidad en la base de datos a donde se hizo la conexión. Para el ejercicio se creará una tabla PRODUCTO con los atributos ID, MARCA, NOMBRE, PRECIO.

Se crea la clase java para la entidad, con las anotaciones correspondientes como se hace normalmente JPA.

package pkg.sw.repository;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="SW_TEST_PRODUCTS") 
public class Product implements Serializable {

 private static final long serialVersionUID = 1L; 
 @Id
    @Column(name = "ID")    
    private Integer id; 
 @Column(name = "NOMBRE")
    private String nombre;
    @Column(name = "PRECIO")
    private Integer precio;
    @Column(name = "MARCA")
    private String marca;
    
 public Integer getID() {
  return id;
 }
 public void setID(Integer id) {
  id = id;
 }
 public String getNOMBRE() {
  return nombre;
 }
 public void setNOMBRE(String nombre) {
  nombre = nombre;
 }
 public Integer getPRECIO() {
  return precio;
 }
 public void setPRECIO(Integer precio) {
  precio = precio;
 }
 public String getMARCA() {
  return marca;
 }
 public void setMARCA(String marca) {
  marca = marca;
 }
 
 public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("nombre: " + nombre + ",");
        buffer.append("precio: " + precio + ",");
        buffer.append("marca: " + marca);
        return buffer.toString();
    }

}

Adicionalmente se hizo la operación toString, simplemente para devolver la información del objeto en una cadena.

Crear el DAO: 
Interface: ProductDao.java 

package pkg.sw.repository;

public interface ProductDao {

 public String getProductList();
 public void persistProduct(Product prod);

}

Implementación: ProductDaoImpl.java: Donde se pone la anotación @Repository que es el estereotipo de Spring para la capa de persistencia, se inicializa el EntityManager para luego ser usado en las operaciones, por ejemplo para éste caso de consulta y de persistencia.

package pkg.sw.repository;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import pkg.sw.repository.ProductDao;
import pkg.sw.repository.Product;

import java.util.List;

@Repository(value = "productDaoSW")
public class ProductDaoImpl implements ProductDao {
 
 private EntityManager em = null;

    /*
     * Sets the entity manager.
     */
    @PersistenceContext
    public void setEntityManager(EntityManager em) {
        this.em = em;
    }
    
    @Transactional(readOnly = true)
 public String getProductList()
 {     
     List _products = em.createQuery("select p from Product p order by p.ID").getResultList();
     
     StringBuffer buffer = new StringBuffer();        
        
     for (Product p : _products)
     {
      buffer.append(p.toString() + "
");
     }
          
     return  buffer.toString();     
 }    
    
    @Transactional(readOnly = false)
    public void persistProduct(Product prod) {
        em.persist(prod);
    }

}

Para el ejercicio se crearon dos operaciones una de consulta a la tabla y otra de inserción.

Ajustar el Servicio
Las clase del servicio se ajustan para utilizar las dos operaciones expuestas en el DAO, se inyectará el DAO con @Autowired de la misma forma como se ha hecho antes.
Interface: ProductService.java

package pkg.sw.service;

import pkg.sw.repository.Product;

public interface ProductService {

 public String getProducts();
 public void saveProduct(Product prod);

}

Implementación: ProductServiceImpl.java: Donde se inyecta el DAO y se crean las operaciones para mostrar la lista de productos desde la tabla de la base de datos y para guardar un nuevo registro.

package pkg.sw.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import pkg.sw.repository.Product;
import pkg.sw.repository.ProductDao;
import pkg.sw.service.ProductService;


@Service
public class ProductServiceImpl implements ProductService{
 
  @Autowired
  private ProductDao productDao;
  
  public void setProductDao(ProductDao productDao) {
        this.productDao = productDao;
     }
  
 public String getProducts()
 {
  String _products = productDao.getProductList();
  return _products;
 }
 
 public void saveProduct(Product prod)
 {
  productDao.persistProduct(prod);
 }
}

Ajustar el controlador:
Como ya se tenía inyectado el servicio en el controlador, ahora se va a actualizar para que invoque las nuevas operaciones creadas, se redireccionará al JSP hello para mostrar la lista de productos desde la base de datos, y se enviará al JSP addProduct para registrar un nuevo registro en la base de datos.

PersistenceController.java

package pkg.sw.controller;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import pkg.sw.repository.Product;
import pkg.sw.service.ProductService;

@Controller
@RequestMapping("/")
public class PersistenceController {

 @Autowired
 private ProductService productService;
 
 @RequestMapping("/hello") 
 public ModelAndView viewDate () {  
  
  return new ModelAndView("hello", "listProducts", productService.getProducts());
 }
 
 @RequestMapping(value="/addProduct", method = RequestMethod.GET)
    protected Product formBackingObject(HttpServletRequest request) throws ServletException {
   Product product = new Product();         
        return product;
    }

 @RequestMapping(value="/addProduct", method = RequestMethod.POST)
 public ModelAndView onSubmit(@Valid Product product, BindingResult result)
 {  
  product.setID(5);
  productService.saveProduct(product);
  
  ModelAndView mv = new ModelAndView("hello");
  mv.addObject("listProducts", productService.getProducts());
  mv.addObject("msg", "Producto insertado.");  
  return mv;
  
 }
}

Hay que anotar que se hicicron dos operaciones en el controlador para "/addProduct", una por POST y otra por GET. 
La que va por GET es la que se invoca al inicio, simplemente en el link del JSP index hacia el JSP addProduct, ésta devuelve un nuevo objeto del tipo de la entidad Product. En el siguiente paso del JSP se explicará más al respecto.

@RequestMapping(value="/addProduct", method = RequestMethod.GET)
    protected Product formBackingObject(HttpServletRequest request) throws ServletException {
   Product product = new Product();         
        return product;
    }

La que va por POST onSumit, se ejecutará al oprimir el botón submit del formulario en el JSP, es en ésta operación donde se persiste el producto que se recibe en el parámetro y finalmente se direcciona a el JSP hello para ver la lista de los productos de la base de datos.

@RequestMapping(value="/addProduct", method = RequestMethod.POST)
 public ModelAndView onSubmit(@Valid Product product, BindingResult result)
 {  
  productService.saveProduct(product);
  
  ModelAndView mv = new ModelAndView("hello");
  mv.addObject("listProducts", productService.getProducts());
  mv.addObject("msg", "Producto insertado.");  
  return mv;
  
 }

Ajuste de JSPs:

hello.jsp: Simplemente muestra los dos parámetros que recibe desde el modelo:

• listProducts
• msg

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Soluciones Web</title>
</head>
<body>
 <h2>Respuesta desde el controlador Spr</h2> 
 <div>${listProducts}</div>
 <br/>
 <br/>
 <div>${msg}</div>
 <br/>
 <a href="/SWHelloWorlPersistence/">Home</a>
</body>
</html>

Creación de addProduct.jsp: para éste JSP se va a utilizar <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %> que son las etiquetas de Formulario de Spring, las cuales tienen atributos que permitirán mapear la entidad Product para pasarla al controlador. No se profundzará el uso de Formulario de Spring en ésta entrada.

addProduct.jsp

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Soluciones Web</title>
</head>
<body>
 <h3>Add Product</h3> 
 <form:form method="post" commandName="product">
  ID<form:input path="ID"/>
  Marca<form:input path="MARCA"/>
  Nombre<form:input path="NOMBRE"/>
  Precio<form:input path="PRECIO"/>
  <input type="submit" value="Enviar">
 </form:form>
 <a href="/SWHelloWorlPersistence/">Home</a>
</body>
</html>

Formulario de Spring: El atributo commandName="product" de la etiqueta form, es el parámetro que se recibe desde la invocación get, e inicializa el objeto.

<form:form method="post" commandName="product">

Product product = new Product();         
        return product;

Los atributos path de los input así mismo deben ser los nombres de los atributos del objeto, para éste caso de Product:

ID<form:input path="id"/>
Marca<form:input path="marca"/>
Nombre<form:input path="nombre"/>
Precio<form:input path="precio"/>
<input type="submit" value="Enviar">

     @Id
    @Column(name = "ID")    
    private Integer id; 
 @Column(name = "NOMBRE")
    private String nombre;
    @Column(name = "PRECIO")
    private Integer precio;
    @Column(name = "MARCA")
    private String marca;

De ésta manera se envía el objeto Product seteado al controlador, y como el formulario está con método POST se dispara la operación de persistencia en el controlador.

Probar la aplicación:

Lista de productos:

Adicionar Producto:

Comprobar la inserción en la base de datos:

Conclusión
Se ha mostrado la configuración de la capa de persistencia y se obtienen los conceptos de las configuraciones XML de Spring para una aplicación completa:

Desplegar en Weblogic con Maven

Para permitir el despliegue en Weblogic con Maven, es necesario instalar el plugin de Oracle.

La instalación debe hacerse desde la consola de Maven, en una instalación stand-alone de Maven se accede a la consola, y si se usa el Maven integrado en el Eclipse, se puede hacer a través del IDE.

En ésta entrada se mostrará a través de Eclipse.

(NOTA: Si no tiene experiencia con Maven, es recomendable realizar éste tutorial después de haber terminado el tutorial Hola Mundo de Spring para estar familiarizado con los conceptos del POM.)

Ubicar la librería

Ubicar la librería: oracle-maven-sync-12.2.1.jar en su directorio de instalación de Weblogic 12c Local, por ejemplo:

C:\Oracle\Middleware122100\Oracle_Home\oracle_common\plugins\maven\com\oracle\maven\oracle-maven-sync\12.2.1

Crear un proyecto dummy en Eclipse

Crear un proyecto Dummy de Maven, sin arquetipos llamado Lib:

En Eclipse New --> Maven Project

Una vez creado el proyecto, ir a la ubicación del proyecto y copiar los dos archivos de la librería desde C:\Oracle\Middleware122100\Oracle_Home\oracle_common\plugins\maven\com\oracle\maven\oracle-maven-sync\12.2.1 a la ruta raíz del proyecto Lib.

Instalar la librería

Ejecutar desde Eclipse el siguiente comando de Maven:

Menu Run --> Run Configurations…

Sobre Maven Build --> New:

Aparece:

Asignar un nombre como: Install_WeblogicSync

Con el botón Workspace, seleccionar el proyecto dummy Lib creado.

Finalmente en el campo Goals pegar el comando:

install:install-file -DpomFile="oracle-maven-sync-12.2.1.pom" -Dfile="oracle-maven-sync-12.2.1.jar"

--> Apply --> Run...
Esta debería ser la salida de la consola indicando que la instalación se hizo satisfactoriamente:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building Lib 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- maven-install-plugin:2.4:install-file (default-cli) @ Lib ---
[INFO] Installing C:\eclipse_work\workspace\Lib\oracle-maven-sync-12.2.1.jar to C:\Users\Marìa juliana\.m2\repository\com\oracle\maven\oracle-maven-sync\12.2.1-0-0\oracle-maven-sync-12.2.1-0-0.jar
[INFO] Installing C:\eclipse_work\workspace\Lib\oracle-maven-sync-12.2.1.pom to C:\Users\Marìa juliana\.m2\repository\com\oracle\maven\oracle-maven-sync\12.2.1-0-0\oracle-maven-sync-12.2.1-0-0.pom
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.845 s
[INFO] Finished at: 2016-09-24T21:02:36-05:00
[INFO] Final Memory: 6M/155M
[INFO] ------------------------------------------------------------------------

Para verificar la instalación se puede ejecutar el siguiente comando repitiendo los pasos anteriores:

help:describe -Dplugin="com.oracle.maven:oracle-maven-sync" -Ddetail

El resultado final debería ser similar a:

To override the localRepository target used by the plugin, you can specify
    the following option on the command-line:
    -Dmaven.local.repo=/alternate/path/to/repository
    
    To supply an alternate settings.xml for purposes of this operation, use the
    --settings option. For example:
    
     mvn --settings /alternate/path/settings.xml ... 
    ...or in your POM like this:
     
         com.oracle.maven
         oracle-maven-sync
         12.2.1-0-0
         
           /home/mark/Oracle/Middleware
           false
         
        

For more information, run 'mvn help:describe [...] -Ddetail'

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 9.992 s
[INFO] Finished at: 2016-09-24T21:07:09-05:00
[INFO] Final Memory: 11M/133M
[INFO] ------------------------------------------------------------------------

Iniciar sincronización con Oracle

De la misma manera que los comandos anteriores, desde eclipse, ejecutar el comando Maven de Sincronización, donde se usa el comando push para la instalación del repositorio local del plugin.
El parámetro DoracleHome especifica la ruta de instalación de su Weblogic:

C:\Oracle\Middleware122100\Oracle_Home

com.oracle.maven:oracle-maven-sync:push -DoracleHome=C:\Oracle\Middleware122100\Oracle_Home

--> Apply --> Run...

Este proceso puede tardar un poco porque sincroniza el repositorio local de Maven (.m2) con el repositorio de Oracle. La salida deberá ser similar a:

SUMMARY
[INFO] ------------------------------------------------------------------------
[INFO] PUSH SUMMARY - ARTIFACTS PROCESSED SUCCESSFULLY
[INFO] ------------------------------------------------------------------------
[INFO] Number of artifacts pushed: 4540
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] PUSH SUMMARY - ERRORS ENCOUNTERED
[INFO] ------------------------------------------------------------------------
[INFO] No issues encountered.
[INFO] 
[INFO] IMPORTANT NOTE
[INFO] This operation may have added/updated archetypes in your repository.
[INFO] To update your archetype catalog, you should run:
[INFO] 'mvn archetype:crawl -Dcatalog=$HOME/.m2/archetype-catalog.xml'
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 10:24 min
[INFO] Finished at: 2016-09-24T21:26:26-05:00
[INFO] Final Memory: 11M/89M
[INFO] ------------------------------------------------------------------------

Como indica la salida del paso anterior, ([INFO] To update your archetype catalog, you should run: [INFO] 'mvn archetype:crawl -Dcatalog=$HOME/.m2/archetype-catalog.xml')se debe ahora realizar la actualización del catálogo local con el siguiente comando siguiendo nuevamente los mismos pasos:

archetype:crawl -Dcatalog=C:/Users/[su_usuario]/.m2/archetype-catalog.xml

Donde se debe especificar la ubicación del directorio .m2 local.

--> Apply --> Run...

La salida deberá ser similar a:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 26.524 s
[INFO] Finished at: 2016-09-24T21:35:17-05:00
[INFO] Final Memory: 11M/223M
[INFO] ------------------------------------------------------------------------

Modificar /.m2/settings.xml

Se debe agregar el plugin group a /.m2/settings.xml​:

Abrir el archivo /.m2/settings.xml​, ubicar las etiquetas <pluginGroups> y adicionar:

<pluginGroups>
    <!-- pluginGroup
     | Specifies a further group identifier to use for plugin lookup.
    <pluginGroup>com.your.plugins</pluginGroup>
    -->
 <pluginGroup>com.oracle.weblogic</pluginGroup>
  </pluginGroups>

Uso del plugin

Para usar el plugin desde Eclipse existen dos formas, apoyándose en el POM.xml y con parámetros desde comandos. En este ejemplo para mostrar las dos formas se configurará el DEPLOY desde POM, y el UNDEPLOY desde comandos.

Uso con POM.XML
Si existe la etiqueta: <pluginManagement> dentro de la etiqueta <build> eliminarla.

Adicionar en la lista de plugins, la configuración del plugin weblogic-maven-plugin: Donde se especifica, servidor Weblogic, usuario y contraseña, fuente, destino, etc. En éste ejemplo para no repetir el nombre del war se ha creado la variable DName en la etiqueta de propiedades, de manera similar a como se usa para manejar versiones:

<properties>
        <java.version>1.8</java.version>
        <DName>SpringRest01</DName>
  </properties>

El fragmento del plugin dentro de la lista de plugins de la etiqueta build quedará similar a:

   <!-- Oracle Weblogic -->
   <plugin>
        <groupId>com.oracle.weblogic</groupId> 
        <artifactId>weblogic-maven-plugin</artifactId> 
        <version>12.2.1-0-0</version>
        <executions>         
          <!--Deploy the application to the server-->
          <execution>
            <id>wls-deploy</id>
            <phase>pre-integration-test</phase> 
            <goals> 
              <goal>deploy</goal>
            </goals>
            <configuration> 
              <!--The admin URL where the app is deployed. Here use the plugin's default value t3://localhost:7001-->
              <!--adminurl>http://localhost:7001</adminurl-->
              <user>weblogic</user> 
              <password>weblogic1</password>
              <!--The location of the file or directory to be deployed-->
              <source>${project.build.directory}/${DName}.${project.packaging}</source>
              <!--The target servers where the application is deployed. Here use the plugin's default value AdminServer-->
              <targets>ClusterHome</targets>
              <verbose>true</verbose> 
              <!--The deployment name of the application-->
              <name>${DName}</name>
            </configuration>             
          </execution> 
        </executions>
    </plugin>

Donde se especifica: El GAV del plugin y los detalles de la ejecución para el goal deploy. 

Allí se especifica servidor, usuario y contraseña. Además la fuente que para el caso usa la variable DName creada, y referencia a project.build.directory que es el directorio target del proyecto, y define la extensión con project.packaging que para el caso es WAR según como se definió en el POM <packaging>war</packaging>.

Adicionar la etiqueta distributionManagement que especifica la URL del repositorio local de Maven, es decir el directorio .m2.

<!-- distribution -->
  <distributionManagement>
   <repository>
    <uniqueVersion>false</uniqueVersion>
     <id>WLIntegr</id>
     <name>WLS Integrate</name>
    <url>file:///C:/Users/SU_USUARIO/.m2/repository/</url> 
        <layout>default</layout>
   </repository>
  </distributionManagement>

Para éste ejemplo el POM.XML completo queda similar a:

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>spring.io.guide01 </groupId>
  <artifactId>spring.io.guide01 </artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <packaging>war</packaging>
  
  <dependencies>
    <!-- Spring MVC -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.2.RELEASE</version>
  </dependency>
  
  <!-- Jackson Core (Conver to JSON) -->
  <dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.5.3</version>
  </dependency>
  
  <!-- Servlet -->
  <dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>3.1.0</version>
  </dependency>  
  </dependencies>
  
  <properties>
        <java.version>1.8</java.version>
        <DName>SpringRest01</DName>
  </properties>
  
  <!-- distribution -->
  <distributionManagement>
   <repository>
    <uniqueVersion>false</uniqueVersion>
     <id>WLIntegr</id>
     <name>WLS Integrate</name>
    <url>file:///C:/Users/SU_USUARIO/.m2/repository/</url> 
        <layout>default</layout>
   </repository>
  </distributionManagement>
    
  <build>   
    <plugins>
    
    <!-- MavenCompiler  -->
    <plugin>
            <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.5.1</version>
      <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
                
    <!-- WAR config  -->
  <plugin>
   <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-war-plugin</artifactId>
      <version>2.4</version>
   <configuration>
    <warSourceDirectory>src/main/webapp</warSourceDirectory>
    <warName>${DName}</warName>
    <failOnMissingWebXml>false</failOnMissingWebXml>
   </configuration>
  </plugin>
  
  <!-- Oracle Weblogic -->
  <plugin>
        <groupId>com.oracle.weblogic</groupId> 
        <artifactId>weblogic-maven-plugin</artifactId> 
        <version>12.2.1-0-0</version>
        <executions>         
          <!--Deploy the application to the server-->
          <execution>
            <id>wls-deploy</id>
            <phase>pre-integration-test</phase> 
            <goals> 
              <goal>deploy</goal>
            </goals>
            <configuration> 
              <!--The admin URL where the app is deployed. Here use the plugin's default value t3://localhost:7001-->
              <!--adminurl>http://localhost:7001</adminurl-->
              <user>weblogic</user> 
              <password>weblogic1</password>
              <!--The location of the file or directory to be deployed-->
              <source>${project.build.directory}/${DName}.${project.packaging}</source>
              <!--The target servers where the application is deployed. Here use the plugin's default value AdminServer-->
              <targets>ClusterHome</targets>
              <verbose>true</verbose> 
              <!--The deployment name of the application-->
              <name>${DName}</name>
            </configuration>             
          </execution> 
        </executions>
      </plugin>
    
     </plugins>
  </build>
  
</project>

Se debe actualizar el proyecto Maven (ALT  + F5) para que tome los cambios en el POM.XML

Ejecutar el despliegue

Como se ha visto anteriormente se hará la ejecución vía Run --> Run Configurations…

• Name: Deploy
• Base Directory: En Workspace seleccionar el proyecto.
• Goals: compile package deploy

Apply --> Run: La consola deberá tener una salida similar a:

…
…
[INFO] --- weblogic-maven-plugin:12.2.1-0-0:deploy (wls-deploy) @ spring.io.guide01.noBoot ---
[INFO] Command flags are: -noexit -deploy -username weblogic -password ******* -name SpringRest01 -source C:\eclipse_work\workspace\spring.io.guide01.noBoot\target\SpringRest01.war -targets ClusterHome -verbose -adminurl t3://localhost:7001
weblogic.Deployer invoked with options:  -noexit -deploy -username weblogic -name SpringRest01 -source C:\eclipse_work\workspace\spring.io.guide01.noBoot\target\SpringRest01.war -targets ClusterHome -verbose -adminurl t3://localhost:7001
<25 10:33:28="" am="" cot="">     
Task 42 initiated: [Deployer:149026]deploy application SpringRest01 on ClusterHome.
Task 42 completed: [Deployer:149026]deploy application SpringRest01 on ClusterHome.
Target state: deploy completed on Cluster ClusterHome

Target Assignments:
+ SpringRest01  ClusterHome
[INFO] 
[INFO] --- maven-install-plugin:2.4:install (default-install) @ spring.io.guide01.noBoot ---
[INFO] Installing 
…
…
[INFO] 
[INFO] --- maven-deploy-plugin:2.7:deploy (default-deploy) @ spring.io.guide01.noBoot ---
[INFO] Downloading: file:///C:/Users/USER/.m2/repository/spring/io/guide01/noBoot/spring.io.guide01.noBoot/0.0.1-SNAPSHOT/maven-metadata.xml
…
… file:///C:/Users/USER/.m2/repository/spring/io/guide01/noBoot/spring.io.guide01.noBoot/maven-metadata.xml (308 B at 75.2 KB/sec)
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 33.521 s
[INFO] Finished at: 2016-09-25T10:33:44-05:00
[INFO] Final Memory: 31M/462M
[INFO] ------------------------------------------------------------------------

Y el despliegue se deberá ver reflejado en la lista de despliegues de Weblogic en el destino seleccionado, por ejemplo:

Uso con comandos

Como ya se tiene definida la variable DName en las propiedades del POM, se pueda hacer uso de la misma en los comandos.

Para hacer el unDeploy, se debe construir el comando especificando PLUGIN:GOAL + PARAMETROS. Para el ejemplo queda de la siguiente manera:

com.oracle.weblogic:weblogic-maven-plugin:undeploy -Duser=weblogic -Dpassword=weblogic1 -Dname=${DName}  -Dadminurl=http://localhost:7101

Donde se ha especificado:

• Usuario: -Duser=weblogic
• Contraseña -Dpassword=weblogic1
• Nombre del despliegue a eliminar: -Dname=${DName}

Ejecutar nuevamente desde Run à Run Configurations:

• Name: undeploy
• Base Directory: En Workspace seleccionar el proyecto.
• Goals: El comando indicado.

Apply --> Run: La consola deberá tener una salida similar a:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building spring.io.guide01.noBoot 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- weblogic-maven-plugin:12.2.1-0-0:undeploy (default-cli) @ spring.io.guide01.noBoot ---
weblogic.Deployer invoked with options:  -noexit -undeploy -username weblogic -name SpringRest01 -adminurl t3://localhost:7001
<25 11:01:39="" am="" cot="">     
Task 43 initiated: [Deployer:149026]remove application SpringRest01 on ClusterHome.
Task 43 completed: [Deployer:149026]remove application SpringRest01 on ClusterHome.
Target state: undeploy completed on Cluster ClusterHome

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 18.207 s
[INFO] Finished at: 2016-09-25T11:01:42-05:00
[INFO] Final Memory: 30M/442M
[INFO] ------------------------------------------------------------------------

Referencias

• http://www.oracle.com/technetwork/es/articles/servers-storage-dev/instalar-maven-weblogic-server-12c-3074631-esa.html 
• https://docs.oracle.com/middleware/1221/wls/WLPRG/maven.htm#WLPRG674
• http://www.oracle.com/technetwork/es/articles/servers-storage-dev/uso-plugin-maven-oracle-weblogic-12-3087254-esa.html
• https://docs.oracle.com/middleware/1212/core/MAVEN/config_maven.htm#MAVEN316