Mostrando entradas con la etiqueta spring. Mostrar todas las entradas
Mostrando entradas con la etiqueta spring. Mostrar todas las entradas

SPRING FRAMEWORK - EJECUTANDO PROCEDIMIENTOS ALMACENADOS

SPRING FRAMEWORK - EJECUTANDO PROCEDIMIENTOS ALMACENADOS
FUNDAMENTOS
Puedes usar cualquiera de los métodos query de JdbcTemplate o el método update para ejecutar el procedimiento almacenado, teniendo en cuenta si retorna o no un resultado.
Los procedimientos de SQL Server o MySQL pueden retornar directamente el resultado de una consulta utilizando la sentencia SELECT.
También dispones de la clase StoreProcedure donde dispones de opciones de mayor control para la ejecución de procedimientos almacenados.
SINTAXIS
El objetivo es ejecutar procedimientos almacenados que no tengan parametros de salida.
A continuación tienes la sintaxis que debes utilizar.
jdbcTemplate.update("call procedimiento (?, ?, ...)", parámetros);
PROCEDIMIENTO A EJECUTAR
El ejemplo que muestro a continuación es utilizando Oracle y el modelo es EUREKABANK, que lo encuentras en:
El procedimiento es para registrar una transacción que ejecuta un retiro de una cuenta.
create or replace procedure usp_egcc_retiro
(p_cuenta varchar2, p_importe number,p_empleado varchar2, p_clave varchar2)
as
  v_msg varchar2(1000);
  v_saldo number(12,2);
  v_moneda char(2);
  v_cont number(5,0);
  v_estado varchar2(15);
  v_costoMov number(12,2);
  v_clave varchar2(10);
begin
  -- Lee datos de la cuenta
  select 
    dec_cuensaldo, chr_monecodigo, int_cuencontmov, 
    vch_cuenestado, chr_cuenclave
    into v_saldo, v_moneda, v_cont, v_estado, v_clave
    from cuenta
    where chr_cuencodigo = p_cuenta 
    for update;
  -- Verifica los datos de la cuenta
  if v_estado != 'ACTIVO' then
    raise_application_error(-20001,'Cuenta no esta activa.');
  end if;
  if v_clave != p_clave then
    raise_application_error(-20001,'Datos incorrectos.');
  end if;
  -- Costo de operación
  select dec_costimporte
    into v_costoMov
    from costomovimiento
    where chr_monecodigo = v_moneda;
  -- Verifica el saldo
  v_saldo := v_saldo - p_importe - v_costoMov;
  if v_saldo < 0.0 then
    raise_application_error(-20001,'Saldo insuficiente.');
  end if;
  -- Actualiza la cuenta
  update cuenta
    set dec_cuensaldo = v_saldo,
    int_cuencontmov = int_cuencontmov + 2
    where chr_cuencodigo = p_cuenta;
  -- Registra el movimiento de retiro
  v_cont := v_cont + 1;
  insert into movimiento(chr_cuencodigo,int_movinumero,dtt_movifecha,
    chr_emplcodigo,chr_tipocodigo,dec_moviimporte,chr_cuenreferencia)
    values(p_cuenta,v_cont,sysdate,p_empleado,'004',p_importe,null);
  -- Registra el costo de la operación
  v_cont := v_cont + 1;
  insert into movimiento(chr_cuencodigo,int_movinumero,dtt_movifecha,
    chr_emplcodigo,chr_tipocodigo,dec_moviimporte,chr_cuenreferencia)
    values(p_cuenta,v_cont,sysdate,p_empleado,'010',v_costoMov,null);
  -- Confirmar la Tx
  commit;
exception
  when others then
    v_msg := sqlerrm; -- capturar mensaje de error
    rollback; -- cancelar transacción
    raise_application_error(-20001,v_msg);
end;
EJECUCIÓN DEL PROCEDIMIENTO
A continuación tienes el código Java para ejecutar el procedimiento usp_egcc_retiro:
public void procRetiro
(String cuenta, double importe,String codEmp, String clave) {

  jdbcTemplate.update("call usp_egcc_retiro (?, ?, ?, ?)", 
    cuenta, importe, codEmp, clave);

}
Debes tener en cuenta que la transacción es controlada en el procedimiento almacenado.
VIDEO DEMOSTRATIVO
CODIGO FUENTE - EUREKA-WEB-MYSQL-SPRING
En esta sección te presento un video de una aplicación web desarrollada SPRING FRAMEWORK y MYSQL.
Tú tienes acceso al código fuente de esta aplicación, después del video tienes el enlace.



SPRING FRAMEWORK - JDBC TRANSACCIONES

SPRING FRAMEWORK - TRANSACCIONES
FUNDAMENTOS
Una transacción en un Sistema de Gestión de Bases de Datos (SGBD), es un conjunto de operaciones (instrucciones) que se ejecutan formando una unidad de trabajo, es decir, en forma indivisible o atómica.
CONFIGURACIÓN DEL CONTEXTO
A continuación tienes un ejemplo de la configuración del contexto.
<bean id="dataSource"
  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  <property name="driverClassName" 
            value="oracle.jdbc.driver.OracleDriver" />
  <property name="url" 
            value="jdbc:oracle:thin:@localhost:1521:XE" />
  <property name="username" value="eureka" />
  <property name="password" value="admin" />
  </bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /> </bean>
<tx:annotation-driven transaction-manager="transactionManager" />
PROGRAMACIÓN
A continuación tienes el formato de como debes programar un método donde debes implementar una transacción.
@Transactional(
    propagation=Propagation.REQUIRED, 
    rollbackForClassName={"Exception"}
)
public void insertar( [ parámetros ] ) throws Exception {

  // Proceso

}
EJEMPLO ILUSTRATIVO
El ejemplo que muestro a continuación es utilizando Oracle y el modelo es EUREKABANK, que lo encuentras en:
@Transactional(
  rollbackFor = Exception.class, 
  propagation = Propagation.REQUIRES_NEW)
public void procDeposito(String cuenta, double importe, String codEmp) {
  // Variables
  String sql;
  Map map;
  double saldo;
  int cont;
  // Paso 1: Leer datos de la cuenta
  sql = "select dec_cuensaldo, int_cuencontmov  " 
      + "from cuenta where chr_cuencodigo = ? " 
      + "for update ";
  map = jdbcTemplate.queryForMap(sql, cuenta);
  saldo = Double.parseDouble(map.get("dec_cuensaldo").toString());
  cont = Integer.parseInt(map.get("int_cuencontmov").toString());
  // Paso 2: Actualizar cuenta
  saldo += importe;
  cont++;
  sql = "update cuenta set dec_cuensaldo = ?, " 
    + "int_cuencontmov = ? " 
    + "where chr_cuencodigo = ? ";
  jdbcTemplate.update(sql, saldo, cont, cuenta);
  // Paso 3: Registrar movimiento
  sql = "insert into movimiento(chr_cuencodigo,int_movinumero,"
      + "dtt_movifecha,chr_emplcodigo,chr_tipocodigo,dec_moviimporte) " 
      + "values(?,?,SYSDATE,?,'003',?)";
  jdbcTemplate.update(sql, cuenta, cont, codEmp, importe);
}

VIDEO DEMOSTRATIVO
CODIGO FUENTE - EUREKA-WEB-MYSQL-SPRING
En esta sección te presento un video de una aplicación web desarrollada SPRING FRAMEWORK y MYSQL.
Tú tienes acceso al código fuente de esta aplicación, después del video tienes el enlace.



SPRING FRAMEWORK - CONFIGURACION

SPRING FRAMEWORK - CONFIGURACIÓN
CONTEXTO
El framework más utilizados en el desarrollo web con Java EE es sin duda Spring Framework, en este articulo te presento la configuración de los tres principales archivos:
  • Descriptor de Despliegue: web.xml
  • Dispatcher Servlet: dispatcher-servlet.xml
  • Application Context: applicationContext.xml
El ejemplo está desarrollado con la base de datos EUREKABANK que normalmente utilizo en mis cursos.
DESCRIPTOR DE DESPLIEGUE: web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>
      org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>2</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>*.htm</url-pattern>
  </servlet-mapping>
  <session-config>
    <session-timeout>
      30
    </session-timeout>
  </session-config>
  <welcome-file-list>
    <welcome-file>index.htm</welcome-file>
  </welcome-file-list>
</web-app>
DISPATCHER SERVLET: dispatcher-servlet.xml
<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd">

  <bean id="viewResolver"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver"
        p:prefix="/WEB-INF/view/"
        p:suffix=".jsp" />

  <context:annotation-config />
 
  <context:component-scan base-package="pe.egcc.eureka.controller" />
 
</beans>
APPLICATION CONTEXT: applicationContext.xml
<?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:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

  <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource"
        p:driverClassName="com.mysql.jdbc.Driver"
        p:url="jdbc:mysql://localhost:3306/eurekabank"
        p:username="eureka"
        p:password="admin" />
 
  <bean id="jdbcTemplate"  
        class="org.springframework.jdbc.core.JdbcTemplate" >
        <property name="dataSource" ref="dataSource"/>
  </bean>
 
  <context:annotation-config />
  <context:component-scan base-package="pe.egcc.eureka.service"/>

  <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
  </bean>

  <tx:annotation-driven transaction-manager="transactionManager" />

</beans>
CODIGO FUENTE - EUREKA-WEB-MYSQL-SPRING
En esta sección te presento un video de una aplicación web desarrollada SPRING FRAMEWORK y MYSQL.
Tú tienes acceso al código fuente de esta aplicación, después del video tienes el enlace.



EUREKA-WEB-MYSQL-SPRING

SQL SERVER ORACLE MYSQL JAVA JDBC MVC DAO PATRONES ANDROID SERVLETS JSP WEB JAVASCRIPT JSON
DESCRIPCIÓN
En este video te explico cómo ejecutar el código fuente de una aplicación Java Web, utilizando HTML, CSS, JavaScript, AJAX y JSON, base de datos MYSQL y Spring Framework.
IMÁGENES DEL APLICATIVO
A continuación te muestro algunas imágenes del aplicativo.
CÓMO OBTENER EL CÓDIGO FUENTE
ABONO O TRANSFERENCIA A CUENTA BANCARIA
Si estás interesado en el código fuente, el costo es de 200.0 Soles.
El abono lo puedes hacer en una de las siguientes cuentas:
  • BCP: 191-10378619-0-52
Luego envías un correo a egcc.fuente@gmail.com con los siguientes datos:
  1. Foto del voucher.
  2. Identificador del código fuente: EUREKA-WEB-MYSQL-SPRING
Luego te respondere en el mismo correo, indicando el enlace para que descargues el código fuente.
PAGO POR PAYPAL
Si estás interesado en el código fuente, su costo es de 70 Dólares.
Debes tener cuenta en PayPal.
Después de realizar el pago, tienes acceso al código fuente.


PROGRAMANDO PENSANDO EN SERVICIOS - Parte 2

PROGRAMANDO PENSANDO EN SERVICIOS – EJEMPLO 1
EJEMPLO 1
Este primer ejemplo tiene como finalidad entender el concepto de programación en capas y programar pensando en servicios.
REQUERIMIENTO
Crear un programa para calcular la suma y el producto de dos números.
ANÁLISIS
Se necesita un componente con dos servicios:
  1. Calcular la suma de dos números.
  2. Calcular el producto de dos números.
IMPLEMENTACIÓN
En el próximo articulo estare desarrollando el patrón DTO.


CODIGO FUENTE
En esta sección te presento un video que una aplicación CLIENTE-SERVIDOR.
Tú tienes acceso al código fuente de esta aplicación, después del video tienes el enlace.



PROGRAMANDO PENSANDO EN SERVICIOS – Parte 1

PROGRAMANDO PENSANDO EN SERVICIOS – PARTE 1
PENSANDO EN SERVICIOS
Como docente de programación, una de las preguntas que los estudiantes realizan con mucha frecuencia es:
¿Cómo empiezo el proyecto?
La mayoría que se inicia en programación, como es lógico, no tiene claro cómo debe iniciar su proyecto, esto se complica aún más cuando su primer profesor le indica que realice una ventana, y para programarla debe hacer doble click en el botón y empiece a programar.
Pienso, que una parte del problema está en que lo primero que se enseña a los futuros programadores es poner el código de la lógica de un requerimiento en el evento click de un botón, por lo tanto, creen que es así como se debe programar todas las ventanas que requiere su aplicación.
Este estilo de programación no creo que sea el más adecuado, tiene muchos problemas, como por ejemplo:
  1. Repites bloques de código en varias partes de tu aplicación, esto dificulta su mantenimiento.
  2. El mantenimiento de la aplicación rápidamente se vuelve complicado, en muy poco tiempo, tu aplicación se parece más al juego de Jenga.
  3. Escalar tu aplicación, por ejemplo, de Cliente-Servidor a Web se hace prácticamente imposible.
  4. Si cuando estas a la mitad de un proyecto, te cambian de motor de base de datos, actualizar el código se hace una tarea muy complicada.
Voy hacer referencia a Danny Thorpe:
Programar sin una arquitectura en mente es como explorar una gruta sólo con una linterna: no sabes dónde estás, dónde has estado ni a dónde vas.
Pienso que primero debemos pensar en una arquitectura, por ejemplo, pensar en dos capas, una capa de servicios (service) donde se implemente la solución del problema a resolver, y una capa para la interfaz de usuario (view).
Pensar en una capa de servicios para implementar la solución de un requerimiento o problema da muchas ventajas, entre las cuales tenemos:
  1. Permite concentrarnos en la solución.
  2. Facilita las pruebas, algo que no debes dejar de hacer.
  3. Tu solución puedes escalarla fácilmente.
  4. El mantenimiento del código es más fácil.
En el siguiente artículo estaré desarrollando un ejemplo ilustrativo.


CODIGO FUENTE
En esta sección te presento un video que una aplicación CLIENTE-SERVIDOR.
Tú tienes acceso al código fuente de esta aplicación, después del video tienes el enlace.



GIT Y GITHUB

GIT Y GITHUB
FUNDAMENTOS

Manejar un programa para la gestión de versiones de tus proyectos de software es fundamental.

GIT es quizás en este momento el software para manejar versiones mas utilizado.

GitHub es un repositorio en web que te permite manejar proyectos gratuitos y privados. Existen otras versiones pero GitHub creo que es el mas utilizado.

En esta oportunidad te presento una manual del uso de Git y GitHub, espero que te sea útil.

MANUAL
CODIGO FUENTE

En esta sección te presento un video que una aplicación JAVA WEB.

Tú tienes acceso al código fuente de esta aplicación, después del video tienes el enlace.


Haz click aquí para acceder al código fuente