Introducción

La aplicación que vamos a realizar es la siguiente: nosotros realizamos una pantalla en la cuál vamos a meteremos nuestros 16 dígitos de nuestra tarjeta y nos devolverá el saldo o los movimentos que realizamos con la tarjeta, nuestra aplicación será con restful webservice,spring mvc con dos submodulos de maven uno donde exponemos el servicio y otro el cliente donde vamos consumir nuestro servicio rest.

Requisitos

UML

spring project

Base de datos

Crearemos una base de datos con dos tablas una para el saldo y otra para movimientos, los insert necesarios para echar a andar nuestra aplicación.
  CREATE DATABASE  IF NOT EXISTS `onlinebalancedb` DEFAULT CHARACTER SET utf8 ;
USE `onlinebalancedb`;
  
  
  
  CREATE TABLE `movimiento` (
  `idMovimiento` int(16) NOT NULL AUTO_INCREMENT,
  `idTarjeta` bigint(16) NOT NULL,
  `movimiento` varchar(450) NOT NULL,
  `cantidad` double NOT NULL,
  PRIMARY KEY (`idMovimiento`)
) ENGINE=MyISAM AUTO_INCREMENT=12 DEFAULT CHARSET=utf8;
  
  INSERT INTO `movimiento` VALUES (1,1234567890123456,'Abono tarjeta',25000),
  (2,1234567890123456,'Compra en osso',100.5),
  (3,1234567890123456,'Pago gasolina pemez',300),
  (4,1234567890123456,'Compra de boleto ticket monster',15000),
  (5,1234567890123456,'Retiro de cajero',5000),
  (6,1234123456785678,'Abono tarjeta',21000),
  (7,1234123456785678,'Compra comercial valle dorado',5500),
  (8,1234123456785678,'Abono tarjeta',10000),
  (9,1111222233334444,'Abono tarjeta',40000),
  (10,1111222233334444,'retiro cajero',5000),
  (11,1111222233334444,'retiro tarjeta',3000);
  
  CREATE TABLE `saldo` (
  `IDTARJETA` bigint(16) NOT NULL,
  `SALDO` double DEFAULT NULL,
  PRIMARY KEY (`IDTARJETA`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
  
  INSERT INTO `saldo` VALUES (1234567890123456,19199.5),
  (1234123456785678,29500),
  (1111222233334444,32000);
  
  

Descargar archivo sql

El proyecto de software

El proyecto va a quedara estructurado de la siguiente manera; va ser multimodular un modulo war será la api rest y otro sera un war con el cliente que nos consumira los servicio apoyando en angularjs y un modulo jar para el negocio del sistema.

eclipse maven

Abrimos nuestro IDE eclipse y creamos un proyecto maven
Procedemos a abrir nuestro IDE eclipse y nos vamos al menú y le damos File->New->Maven Project
java project
Seleccionamos Create a simple project (skip archetype selection) y Use default Workspace location y presionamos Next
java project
Ahora llenamos los siguientes datos:
y presionamos finish.
Por que la idea que sea modular para nosotros como proveedores de información necesitamos ofrecer nuestro servicios al usuario final, pero primero necesitamos ofrecer los servicios que se van consumir, una documentación para el developer para que contruya el cliente y una aplicación cliente para que el usuario final le sea trasparente obtener la gama de servicios que ofrece la aplicación web.
java project
En el archivo pom.xml escribimos lo siguiente
  <build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.3</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
			        <verbose>true</verbose>
			        <fork>true</fork>
			        <executable>${JAVA_HOME}/bin/javac</executable>
			        <compilerVersion>1.8</compilerVersion>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
		  		<version>2.4.2</version>
		        <configuration>
		          <jvm>${JAVA_HOME}/bin/java</jvm>
		          <forkMode>once</forkMode>
		        </configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-enforcer-plugin</artifactId>
				<version>1.3.1</version>
				<inherited>true</inherited>
				<executions>
					<execution>
						<id>enforce</id>
						<configuration>
							<rules>
								<DependencyConvergence />
								<requireJavaVersion>
									<version>1.8</version>
								</requireJavaVersion>
							</rules>
						</configuration>
						<goals>
							<goal>enforce</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
		
		
		<pluginManagement>
		    <plugins>
		      <plugin>
		        <groupId>org.eclipse.m2e</groupId>
		        <artifactId>lifecycle-mapping</artifactId>
		        <version>1.0.0</version>
		        <configuration>
		          <lifecycleMappingMetadata>
		            <pluginExecutions>
		              <pluginExecution>
		                <pluginExecutionFilter>
		                  <groupId>org.apache.maven.plugins</groupId>
		                  <artifactId>maven-enforcer-plugin</artifactId>
		                  <versionRange>[1.0.0,)</versionRange>
		                  <goals>
		                    <goal>enforce</goal>
		                  </goals>
		                </pluginExecutionFilter>
		                <action>
		                  <ignore />
		                </action>
		              </pluginExecution>
		            </pluginExecutions>
		          </lifecycleMappingMetadata>
		        </configuration>
		      </plugin>
		    </plugins>
		</pluginManagement>
	</build> 
   
   
   

Una vez realizado esta parte en nuestro editor eclipse selecionamos File->New->Other
java project
Destendemos la pestaña que dice Maven y seleccionamos Maven Module y presionamos Next
java project
En la siguiente pantalla seleccionamos Create a simple project (skip archetype selection) , luego en Module name: lo nombramos como onlinebalance-service y en Parent project: seleccionamos onlinebalance y presionamos Next
java project
Llenamos los siguientes datos:
Por último hacemos clic en Finish
java project
Ahora creamos el modulo core donde tendremos nuestra persistencia de datos y servicios, volvemos a selecionar
File->New->Other
java project
Destendemos la pestaña que dice Maven y seleccionamos Maven Module y presionamos Next
java project
En la siguiente pantalla seleccionamos Create a simple project (skip archetype selection) , luego en Module name: lo nombramos como onlinebalance-core y en Parent project: seleccionamos onlinebalance y presionamos Next
java project
Llenamos los siguientes datos:
Por último hacemos clic en Finish
java project
Ahora vamos a crear el modulo onlinebalance-client File->New->Other. Destendemos la pestaña que dice Maven y seleccionamos Maven Module y presionamos Next
En la siguiente pantalla seleccionamos Create a simple project (skip archetype selection) , luego en Module name: lo nombramos como onlinebalance-client y en Parent project: seleccionamos onlinebalance y presionamos Next
java project
Llenamos los siguientes datos:
Por último hacemos clic en Finish
java project
en onlinebalance-service destender la carpeta que dice src/main/webapp crear la carpeta WEB-INF
java project
java project
Y sobre esta crear el archivo web.xml
java project
java project
En el archivo web.xml escribimos el siguiente código:
 <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">
  <display-name>Archetype Created Web Application</display-name>


  <servlet>
        <servlet-name>mvc-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>    
    <servlet-mapping>
        <servlet-name>mvc-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
   </servlet-mapping>  


<filter>
  <filter-name>charsetFilter</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
  <param-name>encoding</param-name>
  <param-value>UTF-8</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>charsetFilter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>


</web-app>
 
 
 

En el modulo onlinebalance-client destendemos la carpeta que dice src/main/webapp crear la carpeta WEB-INF.Sobre la carpeta creada escribimos un archivo llamado web.xml y escribimos el siguiente código
 
  <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">
  <display-name>Archetype Created Web Application</display-name>


  <servlet>
        <servlet-name>mvc-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>    
    <servlet-mapping>
        <servlet-name>mvc-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
   </servlet-mapping>  


<filter>
  <filter-name>charsetFilter</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
  <param-name>encoding</param-name>
  <param-value>UTF-8</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>charsetFilter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>


</web-app>
  
  

Ahora nos vamos al modulo padre llamado onlinebalanceHaciendo clic derecho y seleccionamos Run As->Maven clean
java project
y en consola aparece lo siguiente:
java project
De nuevo sobre onlinebalanceHacemos clic derecho y seleccionamos Run As->Maven install
java project
y en consola aparece lo siguiente:
java project
Ahora lo que vamos hacer es instalar los jars nos vamos a onlinebalance dejando el archivo pom.xml de la siguiente forma:
 <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>com.tutosoftware.onlinebalance</groupId>
  <artifactId>onlinebalance</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>OnlineBalance</name>
  <properties>
		<obc.version>0.0.1-SNAPSHOT</obc.version>
		<spring.version>5.0.5.RELEASE</spring.version>
		<springfox.version>2.8.0</springfox.version>
		<hibernate.version>5.2.9.Final</hibernate.version>
		<mysql.version>5.1.34</mysql.version>
		<jstl.version>1.2</jstl.version>
		<jsp-api.version>2.1</jsp-api.version>
		<servlet-api.version>3.1.0</servlet-api.version>
		<hibernatevalidator.version>5.3.4.Final</hibernatevalidator.version>
		<jackson-core.version>2.9.5</jackson-core.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
	<dependencyManagement>
  <dependencies>
  <dependency>
	<groupId>com.tutosoftware.onlinebalance</groupId>
	<artifactId>onlinebalance-core</artifactId>
	<version>${obc.version}</version>
	</dependency>
	
	 <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</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-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
       
       <dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-beans</artifactId>
				<version>${spring.version}</version>
			</dependency>
       
       
       
       
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>
  
  
  
    <dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>${springfox.version}</version>
     </dependency>
  
       <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${springfox.version}</version>
        </dependency>
  
  
  
         <!-- Hibernate  dependencies -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        
         <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        
         <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>${hibernatevalidator.version}</version>
       </dependency>
          <!-- mysql  dependencie -->
        
        <dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>${mysql.version}</version>
	   </dependency>
	   
	       <!-- Servlet and JSP -->
        <dependency>
				<groupId>javax.servlet.jsp</groupId>
				<artifactId>jsp-api</artifactId>
				<version>${jsp-api.version}</version>
				<scope>provided</scope>
			</dependency>
			
			
         <dependency>
	     <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
	   <version>${servlet-api.version}</version>
        </dependency>
			
			
			
			<dependency>
				<groupId>javax.servlet</groupId>
				<artifactId>jstl</artifactId>
				<version>${jstl.version}</version>
			</dependency>
			
			
			<dependency>
           <groupId>com.fasterxml.jackson.core</groupId>
           <artifactId>jackson-databind</artifactId>
          <version>${jackson-core.version}</version>
         </dependency>	
			
			
						
   </dependencies>
  </dependencyManagement>
  <build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.3</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
			        <verbose>true</verbose>
			        <fork>true</fork>
			        <executable>${JAVA_HOME}/bin/javac</executable>
			        <compilerVersion>1.8</compilerVersion>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
		  		<version>2.4.2</version>
		        <configuration>
		          <jvm>${JAVA_HOME}/bin/java</jvm>
		          <forkMode>once</forkMode>
		        </configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-enforcer-plugin</artifactId>
				<version>1.3.1</version>
				<inherited>true</inherited>
				<executions>
					<execution>
						<id>enforce</id>
						<configuration>
							<rules>
								<DependencyConvergence />
								<requireJavaVersion>
									<version>1.8</version>
								</requireJavaVersion>
							</rules>
						</configuration>
						<goals>
							<goal>enforce</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
		
		
		<pluginManagement>
		    <plugins>
		      <plugin>
		        <groupId>org.eclipse.m2e</groupId>
		        <artifactId>lifecycle-mapping</artifactId>
		        <version>1.0.0</version>
		        <configuration>
		          <lifecycleMappingMetadata>
		            <pluginExecutions>
		              <pluginExecution>
		                <pluginExecutionFilter>
		                  <groupId>org.apache.maven.plugins</groupId>
		                  <artifactId>maven-enforcer-plugin</artifactId>
		                  <versionRange>[1.0.0,)</versionRange>
		                  <goals>
		                    <goal>enforce</goal>
		                  </goals>
		                </pluginExecutionFilter>
		                <action>
		                  <ignore />
		                </action>
		              </pluginExecution>
		            </pluginExecutions>
		          </lifecycleMappingMetadata>
		        </configuration>
		      </plugin>
		    </plugins>
		</pluginManagement>
	</build> 
  
  
  
  
  
  <modules>
  	<module>onlinebalance-service</module>
  	<module>onlinebalance-core</module>
  	<module>onlinebalance-client</module>
  </modules>
</project> 
  
  
   

Ahora nos posicionamos al proyecto onlinebalance-core ,vamos agregar los jars que vamos a utlizar en el archivo pom.xml y escribimos lo siguiente:
 <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>
  <parent>
    <groupId>com.tutosoftware.onlinebalance</groupId>
    <artifactId>onlinebalance</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>onlinebalance-core</artifactId>
  <name>OnlineBalance Core</name>
  <dependencies>
      <!-- Spring 4 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        
        
         <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        
         <dependency>
      <groupId>io.springfox</groupId>
     <artifactId>springfox-swagger2</artifactId>
     </dependency>
     
     <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
        </dependency>
        
        <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
       </dependency>
        
        
         <!-- Hibernate  dependencies -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        
        
         <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
        </dependency>
        
          <!-- mysql  dependencie -->
        
        <dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	   </dependency>
  
  
  </dependencies>
</project>

Como nuestra persistencia de datos va hacer realizada con hibernate vamos a comenzar por crear nuestra plantilla de hibernate util nos posicionamos en nuestro proyecto onlinebalance-core y en el directorio src/main/java seleccionamos New->Package
java project
y lo nombramos com.tutosoftware.onlinebalance.util y presionamos Finish
java project
Sobre el paquete com.tutosoftware.onlinebalance.util vamos a crear la clase HibernateUtil y escribimos el siguiente código:
  
  package com.tutosoftware.onlinebalance.util;

import java.io.Serializable;
import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class HibernateUtil {
	
	@Autowired
    private SessionFactory sessionFactory;
        
    public <T> Serializable create(final T entity) {
        return sessionFactory.getCurrentSession().save(entity);        
    }
    
    public <T> T update(final T entity) {
        sessionFactory.getCurrentSession().update(entity);   
        return entity;
    }
    
    public <T> void delete(final T entity) {
        sessionFactory.getCurrentSession().delete(entity);
    }

    public <T> void delete(Serializable id, Class<T> entityClass) {
        T entity = fetchById(id, entityClass);
        delete(entity);
    }
    
    @SuppressWarnings("unchecked")  
    public <T> List<T> fetchAll(Class<T> entityClass) {        
        return sessionFactory.getCurrentSession().createQuery(" FROM "+entityClass.getName()).list();        
    }
  
    
    
    
    @SuppressWarnings("unchecked")  
    public <T> List<T> fetchAll(String hql) {        
        return sessionFactory.getCurrentSession().createQuery(hql).list();        
    }
    
    
    
    
    
    public <T> T fetchById(Serializable id, Class<T> entityClass) {
        return (T)sessionFactory.getCurrentSession().get(entityClass, id);
    }
    
    
    @SuppressWarnings("unchecked")
    public <T> T fetchByUniqueResult(String hql) {
        return (T)sessionFactory.getCurrentSession().createQuery(hql).uniqueResult();
    }

}
  
  
  
  

Sobre onlinebalance-core en el directorio src/main/java vamos a crear el paquete com.tutosoftware.onlinebalance.config que sera el paquete que contendrá nuestro bean de invocación para herramienta de documentación de el api rest llamada swagger.
En el paquete com.tutosoftware.onlinebalance.config creamos la clase llamada SwaggerConfig y escribimos lo siguiente:
  package com.tutosoftware.onlinebalance.config;

import java.time.LocalDateTime;
import java.util.Date;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {
	
	@Bean
	public Docket newsApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("api-balance")
                .apiInfo(apiInfo())
                .directModelSubstitute(LocalDateTime.class, Date.class)
                .select()
                .build();
    }
	
	@SuppressWarnings("deprecation")
	private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("OnlineBalance REST api")
                .description("REST api, OnlineBalance")
                .termsOfServiceUrl("http://en.wikipedia.org/wiki/Terms_of_service")
                .contact("kapo1978@hotmail.com")
                .license("Apache License Version 2.0")
                .licenseUrl("http://www.apache.org/licenses/LICENSE-2.0.html")
                .version("2.0")
                .build();
    }

}
  
  
  

Ahora sobre src/main/java vamos crear el paquete llamado com.tutosoftware.onlinebalance.entity y en el creamos la clase Movimiento y escribimos el siguiente código:
  package com.tutosoftware.onlinebalance.entity;

import java.io.Serializable;

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

@Entity
@Table(name="movimiento")
@ApiModel(value = "Movimiento entidad", description = "Datos completos de la entidad movimiento")
public class Movimiento implements Serializable {
	
private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@ApiModelProperty(value = "El id del movimiento", required = true)
	private Long idMovimiento;
	
	@Column
	@ApiModelProperty(value = "Número de tarjeta", required = true)
	private Long idTarjeta;
	
	
	@Column
	@ApiModelProperty(value = "Donde se realizo el movimiento", required = true)
	private String movimiento;
	
	
	@Column
	@ApiModelProperty(value = "Cantidad númerica del movimiento", required = true)
	private Double cantidad;
	
	
    public Movimiento(){}


	public Long getIdMovimiento() {
		return idMovimiento;
	}


	public void setIdMovimiento(Long idMovimiento) {
		this.idMovimiento = idMovimiento;
	}


	public Long getIdTarjeta() {
		return idTarjeta;
	}


	public void setIdTarjeta(Long idTarjeta) {
		this.idTarjeta = idTarjeta;
	}


	public String getMovimiento() {
		return movimiento;
	}


	public void setMovimiento(String movimiento) {
		this.movimiento = movimiento;
	}


	public Double getCantidad() {
		return cantidad;
	}


	public void setCantidad(Double cantidad) {
		this.cantidad = cantidad;
	}

}
  
  

Como podemos ver vamos a documetar el modelo de las entidades.Ahora sobre el paquete com.tutosoftware.onlinebalance.entity creamos la clase Saldo y escribimos:
  package com.tutosoftware.onlinebalance.entity;

import java.io.Serializable;

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

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

@Entity
@Table(name="saldo")
@ApiModel(value = "Saldo entidad", description = "Datos completos de la entidad saldo")
public class Saldo implements Serializable {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	@Id
	@ApiModelProperty(value = "Número de tarjeta", required = true)
	private Long IdTarjeta;
	
	@Column
	@ApiModelProperty(value = "Cantidad del saldo actual", required = true)
	private Double Saldo;
	
	public Saldo(){
		
	}

	public Long getIdTarjeta() {
		return IdTarjeta;
	}

	public void setIdTarjeta(Long idTarjeta) {
		IdTarjeta = idTarjeta;
	}

	public Double getSaldo() {
		return Saldo;
	}

	public void setSaldo(Double saldo) {
		Saldo = saldo;
	}

}
  
  
  
  

Ahora sobre src/main/java vamos crear nuestros DAO para realizar nuestra transacciones con hibernate. creamos el paquete llamado com.tutosoftware.onlinebalance.dao creamos una interface llamada BalanceDAO y escribimos el siguiente código:
  package com.tutosoftware.onlinebalance.dao;

import java.util.List;

import com.tutosoftware.onlinebalance.entity.Movimiento;
import com.tutosoftware.onlinebalance.entity.Saldo;



public interface BalanceDAO {
	
	public List<Movimiento> obtenerMovimientos(long idTarjeta);
	public Saldo obtenerSaldo(long idTarjeta);

}
  
  
  

Ahora vamos a implementar las interfaces creamos un paquete llamado com.tutosoftware.onlinebalance.dao.impl sobre este paquete creamos una clase lamada BalanceDAOImpl y escribimos el siguiente código:
  package com.tutosoftware.onlinebalance.dao.impl;

import java.util.List;

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

import com.tutosoftware.onlinebalance.dao.BalanceDAO;
import com.tutosoftware.onlinebalance.entity.Movimiento;
import com.tutosoftware.onlinebalance.entity.Saldo;
import com.tutosoftware.onlinebalance.util.HibernateUtil;



@Repository
public class BalanceDAOImpl implements BalanceDAO {
	
	@Autowired
	  private HibernateUtil hibernateUtil;
	  
	 public BalanceDAOImpl(){
		 
	 }

	@Override
	public List<Movimiento> obtenerMovimientos(long idTarjeta) {
		// TODO Auto-generated method stub
		String hql = " FROM Movimiento m WHERE m.idTarjeta ="+idTarjeta;
		return hibernateUtil.fetchAll(hql);
	}

	@Override
	public Saldo obtenerSaldo(long idTarjeta) {
		// TODO Auto-generated method stub
		
		return hibernateUtil.fetchById(idTarjeta,Saldo.class);
	}

}
  
  
  

Ahora vamos por nuestra capa de servicio.Primero creamos el paquete llamado com.tutosoftware.onlinebalance.service posteriormente creamos la interface BalanceService y escribimos el siguiente código:
  package com.tutosoftware.onlinebalance.service;

import java.util.List;

import com.tutosoftware.onlinebalance.entity.Movimiento;
import com.tutosoftware.onlinebalance.entity.Saldo;



public interface BalanceService {
	
	public List<Movimiento> obtenerMovimientos(long idTarjeta);
	public Saldo obtenerSaldo(long idTarjeta);

}
  
  

Ahora por supuesto creamos la implementación nombremos otro paquete llamado com.tutosoftware.onlinebalance.service.impl en este paquete nombramos la clase llamada BalanceServiceImpl y escbribimos el siguiente código:
  package com.tutosoftware.onlinebalance.service.impl;

import java.util.List;

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

import com.tutosoftware.onlinebalance.dao.BalanceDAO;
import com.tutosoftware.onlinebalance.entity.Movimiento;
import com.tutosoftware.onlinebalance.entity.Saldo;
import com.tutosoftware.onlinebalance.service.BalanceService;


@Service
@Transactional
public class BalanceServiceImpl implements BalanceService {
	
	@Autowired
	BalanceDAO balanceDAO;

	@Override
	public List<Movimiento> obtenerMovimientos(long idTarjeta) {
		// TODO Auto-generated method stub
		return balanceDAO.obtenerMovimientos(idTarjeta);
	}

	@Override
	public Saldo obtenerSaldo(long idTarjeta) {
		// TODO Auto-generated method stub
		return balanceDAO.obtenerSaldo(idTarjeta);
	}

}
  
  
  
  

Ahora si vamos a la parte mvc nos posicionamos en el proyecto onlinebalance-service y en el archivo pom.xml Escribimos el siguiente código:
  <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>
  <parent>
    <groupId>com.tutosoftware.onlinebalance</groupId>
    <artifactId>onlinebalance</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>onlinebalance-service</artifactId>
  <packaging>war</packaging>
  <name>OnlineBalance  Service</name>
  <build>
		<finalName>onlinebalanceservice</finalName>
		<plugins>	
			<plugin>            
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.3</version>
				<configuration>
					<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
					<webResources>
						<resource>
							<!-- this is relative to the pom.xml directory -->
							<directory>src/main/webapp/WEB-INF</directory>
							<targetPath>WEB-INF</targetPath>
						</resource>
					</webResources>
				</configuration>
			</plugin>
		</plugins>
	</build>
  <dependencies>
	<dependency>
				<groupId>com.tutosoftware.onlinebalance</groupId>
				<artifactId>onlinebalance-core</artifactId>
	</dependency>
	
	
	
   <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>
         <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-beans</artifactId>
         </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        
      <dependency>
      <groupId>io.springfox</groupId>
     <artifactId>springfox-swagger2</artifactId>
     </dependency>
     
     <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
        </dependency>
        
        <!-- Hibernate  dependencies -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        
        
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
        </dependency>
        
       <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
       </dependency>
        
          <!-- mysql  dependencie -->
        
        <dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	   </dependency>
        
         <!-- Servlet and JSP -->
        <dependency>
				<groupId>javax.servlet.jsp</groupId>
				<artifactId>jsp-api</artifactId>
			</dependency>
			
			
         <dependency>
	     <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
        </dependency>
			
			
			
			<dependency>
				<groupId>javax.servlet</groupId>
				<artifactId>jstl</artifactId>
	              </dependency>
        
        
        
     <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
     </dependency>	
       
       
       
       
        
        </dependencies>
</project>
  
  

El spring mvc que vamos a configurar va hacer de la forma xml nos vamos a src/main/webapp/WEB-INF creamos el archivo mvc-dispatcher-servlet.xml y escribimos el siguiente código:
  <?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:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


	<!-- Specifying base package of the Components like Controller, Service, 
		DAO -->
	<context:component-scan base-package="com.tutosoftware.onlinebalance" />
		
	<!-- Getting Database properties -->
	<context:property-placeholder location="classpath:application.properties" />


	
	
	<mvc:annotation-driven />
	
	
	<mvc:resources mapping="swagger-ui.html" location="classpath:/META-INF/resources/"/>
    <mvc:resources mapping="/webjars/**" location="classpath:/META-INF/resources/webjars/"/>
	
	
	
	
	
   
   
	<!-- DataSource -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${database.driverClass}" />
		<property name="jdbcUrl" value="${database.url}" />
		<property name="user" value="${database.username}" />
		<property name="password" value="${database.password}" />

		<property name="acquireIncrement" value="${connection.acquireIncrement}" />
		<property name="minPoolSize" value="${connection.minPoolSize}" />
		<property name="maxPoolSize" value="${connection.maxPoolSize}" />
		<property name="maxIdleTime" value="${connection.maxIdleTime}" />
	</bean>

	<!-- Hibernate SessionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
				<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
			</props>
		</property>
		<property name="packagesToScan" value="com.tutosoftware.onlinebalance.entity"></property>
	</bean>

	<!-- Transaction -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager" />

</beans>
  
  

Nos vamos a al directorio src/main/resources y creamos el archivo application.properties que contendra datos sobre la conexión de nuestra base de datos.Escribimos el siguiente código:
  database.driverClass=com.mysql.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/onlinebalancedb
database.username=admin
database.password=adminlara

#Hibernate related properties
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true

#Connection pool related properties
connection.acquireIncrement=2
connection.minPoolSize=20
connection.maxPoolSize=50
connection.maxIdleTime=600
  
   

Ahora en, src/main/java creamos el paquete com.tutosoftware.onlinebalance.controller y en ese paquete creamos la calse llamada BalanceRestController que tendra todas la acciones de nuestro logggueo en la aplicación.Escribimos el siguiente código:
  package com.tutosoftware.onlinebalance.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutosoftware.onlinebalance.entity.Movimiento;
import com.tutosoftware.onlinebalance.entity.Saldo;
import com.tutosoftware.onlinebalance.service.BalanceService;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;

@RestController
@Api(value = "testbalance", description = "OnlineBalance API", produces = "application/json")
public class BalanceRestController {
	@Autowired
	private BalanceService balanceService;
	
	
	@RequestMapping(value = {"/"},method = RequestMethod.GET)
    public String bienvenido() {//Welcome page, non-rest
		String mensaje ="<h1>Bienvenido para probar los servicios rest</h1>"; 
		       mensaje +="<h2>/movimientos/idTarjeta</h2>";
		       mensaje +="<h2>/saldo/idTarjeta</h2>";
		       mensaje +="<h2>las tarjetas que puedes probar son</h2>";
		       mensaje +="<h2>1234567890123456</h2>";
		       mensaje +="<h2>1234123456785678</h2>";
		       mensaje +="<h2>1111222233334444</h2>";
        return mensaje;
    }
	
	 @RequestMapping(value="/movimientos/{idTarjeta}",method = RequestMethod.GET)
	 @ApiOperation(value = "Obtener movimientos", notes = "Retorna los movimientos de la tarjeta")
	 public List<Movimiento> obtenerMovimentos(@ApiParam( value = "Meter el BIN o Número de tarjeta 16 digitos")
	 @PathVariable long idTarjeta){
		
		 List<Movimiento> movimientoList = balanceService.obtenerMovimientos(idTarjeta);
		 
		 return movimientoList;
		 
	 }
	 
	 
	 @RequestMapping(value="/saldo/{idTarjeta}",method = RequestMethod.GET)
	 @ApiOperation(value = "Obtener saldo", notes = "Retorna el saldo actual de la tarjeta")
	 public Saldo obtenerSaldo(@ApiParam( value = "Meter el BIN o Número de tarjeta 16 digitos")
	 @PathVariable long idTarjeta){
		 
		 Saldo saldo = balanceService.obtenerSaldo(idTarjeta);
		 
		 return saldo;
		 
	 }
	 

}
  
  
   

Api Rest

Aqui es la parte donde nuestro esfuerzo empieza a rendir frutos corremos la aplicación con tomcat y lo que aparece es lo siguiente:
java project
A continuación probamos los movimientos http://localhost:8080/onlinebalanceservice/movimientos/1234567890123456
java project
Ahora probamos el saldo http://localhost:8080/onlinebalanceservice/saldo/1234123456785678
java project
Por supuesto nuestra documentación http://localhost:8080/onlinebalanceservice/swagger-ui.html java project
Hasta este punto vemos que con la documentación es transparente para el developer, pero el usuario final necesita una pantalla en la cual pueda interactuar con nuestro servicio por lo tanto para consumir estos servicios realizamos lo siguiente:
Ahora nos vamos al proyecto onlinebalance-client y el archivo pom.xml escribimos lo siguiente:
 <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>
  <parent>
    <groupId>com.tutosoftware.onlinebalance</groupId>
    <artifactId>onlinebalance</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>onlinebalance-client</artifactId>
  <packaging>war</packaging>
  <name>OnlineBalance Client</name>
  <build>
		<finalName>onlinebalanceclient</finalName>
		<plugins>	
			<plugin>            
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.3</version>
				<configuration>
					<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
					<webResources>
						<resource>
							<!-- this is relative to the pom.xml directory -->
							<directory>src/main/webapp/WEB-INF</directory>
							<targetPath>WEB-INF</targetPath>
						</resource>
					</webResources>
				</configuration>
			</plugin>
		</plugins>
	</build>
  <dependencies>
	
	
	
   <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>
         <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-beans</artifactId>
         </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        
    
        
         <!-- Servlet and JSP -->
        <dependency>
				<groupId>javax.servlet.jsp</groupId>
				<artifactId>jsp-api</artifactId>
			</dependency>
			
			
         <dependency>
	     <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
        </dependency>
			
			
			
			<dependency>
				<groupId>javax.servlet</groupId>
				<artifactId>jstl</artifactId>
			</dependency>
        
       	
		<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
     </dependency>	
       
       
       
       
        
        </dependencies>
</project> 
  
  

Ahora nos vamos a src/main/webapp/WEB-INF y creamos el arhivo mvc-dispatcher-servlet.xml y escribimos el siguiente código:
 
  <?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:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


	<!-- Specifying base package of the Components like Controller, Service, 
		DAO -->
	<context:component-scan base-package="com.tutosoftware.onlinebalance" />
		
	

	
	
	<mvc:annotation-driven />
	
	
	<mvc:resources mapping="/resources/**" location="/resources/" />
    <mvc:resources mapping="/css/**" location="/css/" />
	<mvc:resources mapping="/fonts/**" location="/fonts/" />
	<mvc:resources mapping="/js/**" location="/js/" />
	
	
	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/" />
		<property name="suffix" value=".jsp" />
	</bean>
	
	

</beans>
  
  
  
  

Lo que sigue es irnos a src/main/java y creamos el paquete com.tutosoftware.onlinebalance.controller y en este creamos la clase controlador OnlineBalanceClientController.java
  package com.tutosoftware.onlinebalance.controller;

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


@Controller
public class OnlineBalanceClientController {
	
	@RequestMapping(value = {"/"})
	public ModelAndView mostrarCliente() {
		
		return new ModelAndView("cliente");
	}

}
  
  
  

En src/main/webapp/WEB-INF creamos la carpeta views la primera vista que vamos crear la vamos a nombrar cliente.jsp
  <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<!doctype html>
<html ng-app='myApp'>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">


 
<title>OnlineBalance cliente</title>
   
     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css">
      <link href="css/app.css" rel="stylesheet"></link>
</head>

<body ng-app='myApp' ng-controller="onlineBalanceController">
   <div class="generic-container">


<h3>Consulta tu saldo o movimientos</h3>
<p>
Introduce los 16 dígitos de tu tarjeta.
</p>
 <div class="panel panel-default">
              <div class="panel-heading"><span class="lead">Online Balance </span></div>
<div class="form">

	<label for="idTarjeta">Número de tarjeta:</label>
			
	<input type="text" id="idTarjeta"  ng-model="idTarjeta" placeholder="idTarjeta" maxlength="16" size="16">
				
			

<input type="submit"  value="Obtener Movimientos" class="btn btn-primary btn-sm" ng-click="obtenerMovimientos()" />
				
<input type="submit"  value="Obtener Saldo" class="btn btn-primary btn-sm" ng-click="obtenerSaldo()">
				
</div>
</div>
<div ng-if="movimientos.exist==1">
		
		<div class="panel panel-default">
                <!-- Default panel contents -->
              <div class="panel-heading"><span class="lead">Lista de movimientos </span></div>
              <div class="tablecontainer">
                  <table class="table table-hover">
                      <thead>
                          <tr>
                              <th>Número de movimiento</th>
                              <th>ID tarjeta</th>
                              <th>Movimiento</th>
                              <th>Cantidad</th>
                              
                          </tr>
                      </thead>
                      <tbody>
                          <tr ng-repeat="p in movimientos">
                              <td>{{p.idMovimiento}}</td>
                              <td>{{p.idTarjeta}}</td>
                              <td>{{p.movimiento}}</td>
                              <td>{{p.cantidad}}</td>
                              
                          </tr>
                      </tbody>
                  </table>
              </div>
          </div>
		
		
		
		
		
		
		
	</div>
	<div ng-if="saldo.exist==1">
		<h1>Saldo</h1>
		<pre>
			<h5> ID Tarjeta: {{saldo.idTarjeta}}</h5>
			<h2> Cantidad: {{saldo.saldo}}</h2>
		</pre>
		<hr/>
	</div>


</div>
      <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.4.4/angular.js"></script>
      <script type="text/javascript" src="js/service/onlineBalanceService.js"></script>
     <script type="text/javascript" src="js/controller/onlineBalanceController.js"></script>
	<!--Services-->
	

</body>
</html>
  
  

En src/main/webapp creamos los folder css y este folder creamos el archivo app.css y escribimos el siguiente código:
  body, #mainWrapper {
	height: 70%;
	background-color:rgb(245, 245, 245);
}

body, .form-control{
	font-size:12px!important;
}

.floatRight{
	float:right;
	margin-right: 18px;
}

.has-error{
	color:red;
}

.formcontainer{
	background-color: #DAE8E8;
	padding: 20px;
}

.tablecontainer{
	padding-left: 20px;
}

.generic-container {
  width:80%;
  margin-left: 20px;
  margin-top: 20px;
  margin-bottom: 20px;
  padding: 20px;
  background-color: #EAE7E7;
  border: 1px solid #ddd;
  border-radius: 4px;
  box-shadow: 0 0 30px black;
}

.custom-width {
    width: 80px !important;
}
  
  

En src/main/webapp creamos los folder js y en este folder creamos otro folder llamado controller y escribimos el siguiente archivo javascript llamado onlineBalanceController.js y ponemos lo siguiente:
  angular.module('myApp', ['onlineBalanceService']);
 
angular.module('myApp').controller('onlineBalanceController', ['$scope','balanceRequest',onlineBalanceController]);
function onlineBalanceController($scope, balanceRequest) {
	$scope.movimientos={};
	$scope.obtenerMovimientos = function(){
		balanceRequest.movimientos($scope.idTarjeta).success(function (data){
			$scope.movimientos=data; // Asignaremos los datos de todos los movimientos
			$scope.movimientos.exist=1;
			$scope.saldo.exist=0;
			
		});
	}
	$scope.obtenerSaldo = function(){
		$scope.saldo={};
		balanceRequest.saldo($scope.idTarjeta).success(function (data){
			$scope.saldo=data; // Asignaremos los datos del saldo
			$scope.saldo.exist=1;
			$scope.movimientos.exist=0;
		});
	}
}
  
  
  

En src/main/webapp/js creamos un folder llamado service y escribimos el siguiente archivo javascript llamado onlineBalanceService.js y ponemos lo siguiente:
  angular.module('onlineBalanceService', [])//Declaramos el modulo
	.factory('balanceRequest', function($http) { //declaramos la factory
		var path = "http://localhost:8080/onlinebalanceservice/";//API path
		
		return {
			//Login
			movimientos : function(id){ //Retornara la lista de posts
				global = $http.get(path+'movimientos/'+id);
				return global;
			},
			saldo : function(id){ //retornara el post por el id
				global = $http.get(path+'saldo/'+id);
				return global;	
			}	
		}
	});
  
  
  

Corremos nuestra aplicación con tomcat y no olvidar correr tambien la api rest para que funcione cliente:
java project
Introducimos el valor de una tarjeta y selccionamos Obtener movimientos
java project
Ahora seleccionamos Obtener saldo de la misma tarjeta:
java project

Conclusión

Como vemos el cliente y servidor estan separados uno del otro a veces es importante apoyarnos en una tecnología alterna para consumir nuestro servicio con angularjs,lo que se pudo obervar es mas fácil realizar webservice de tipo rest que soap ya que spring mvc y angular te facilitan la vida y sin contar que para documentar existe springfox-swagger.

Código

https://github.com/josmarlara/onlinebalance.git

Referencias