domingo, 5 de julio de 2015

Iniciando una Aplicación Web con Gradle

Gradle es una herramienta de automatización para la creación de artefactos de software, con esta herramienta podemos automatizar la creación de empaquetados del tipo jar, war, ear y otros. En esta publicación voy a mostrar de manera simple como podemos crear un artefacto del tipo archivo web(war) y copiarlo a un determinado directorio. A diferencia de maven, el archivo de configuración por default es build.gradle, dicho archivo incluirá los comandos para compilar, empaquetar, conectarse a un repositorio de binarios(artifactory, archiva, nexus, etc.) y descargar dichos binarios para su inclusión en el classpath y en la generación del artefacto, también incluirá tareas personalizadas como copiar los artefactos generados a una determinada ruta.

El archivo de configuración build.gradle es el siguiente:
//aplicamos el plugin java sobre las fuentes para que compile las clases
apply plugin: 'java'

//aplicamos el plugin war para que todo lo que esté dentro de src/main/webapp lo copie dentro del war
apply plugin: 'war'

//le indicamos a gradle que genere nuestro artefacto con esta versión
version = '1.1.0'

//indicamos los repositorios de binarios que gradle descargará e incluirá en el classpath de compilación.
repositories {
 mavenCentral()
}

//incluimos las dependencias de nuestra aplicación
dependencies {

 //indicamos una dependencia de compilación, si la dependencia es de compilación
 //entonces además de incluirla en el classpath de compilación también será incluída
 //en el classpath de ejecución(como dependencia en el directorio lib)
 compile group: 'org.aspectj', name: 'aspectjweaver', version: '1.6.2'
 compile group: 'org.springframework', name: 'spring-aop', version: '3.2.3.RELEASE'
 compile group: 'org.springframework', name: 'spring-context', version: '3.2.3.RELEASE'
 compile group: 'org.springframework', name: 'spring-context-support', version: '3.2.3.RELEASE'
 compile group: 'org.springframework', name: 'spring-core', version: '3.2.3.RELEASE'
 compile group: 'org.springframework', name: 'spring-web', version: '3.2.3.RELEASE'
 compile group: 'org.springframework', name: 'spring-webmvc', version: '3.2.3.RELEASE' 
 compile group: 'org.springframework', name: 'spring-beans', version: '3.2.3.RELEASE'
 compile group: 'org.springframework', name: 'spring-jdbc', version: '3.2.3.RELEASE'
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    
    //a diferencia del anterior esta dependencia solo servirá para compilar
    //se entiende que en tiempo de ejecución será proveída por el servidor o contenedor de aplicaciones
    providedCompile group: 'javax.servlet', name:'javax.servlet-api', version: '3.1.0'
    
    //a diferencia de los 2 tipos de dependencias anteriores, esta dependencia solo será incluída
    //en la fase de testing.  
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

//creamos una tarea que copiará los artefactos generados a una determinada ruta en nuestro filesystem
task copiarGeneradosAServer{
  doLast{
     copy {
       from 'build/libs'
       into 'D:/Projects/4.Install/1.Servers/3.Weblogic/wls12130/user_projects/domains/naboo/autodeploy'
       include '*.war'
     }   
  }

}



El comando para ejecutar el empaquetamiento y su resultado es el siguiente:
J:\proyectos\testing>gradle clean build copiarGeneradosAServer
:clean
:compileJava
:processResources UP-TO-DATE
:classes
:war
:assemble
:compileTestJava UP-TO-DATE
:processTestResources
:testClasses
:test UP-TO-DATE
:check UP-TO-DATE
:build
:copiarGeneradosAServer

BUILD SUCCESSFUL

Total time: 7.204 secs
J:\temporal\testing\testing>

el proyecto completo te lo puedes bajar desde esta rama en github

martes, 10 de agosto de 2010

Spring Security Mediante Base de Datos

En el post anterior les mostré como implementar spring security de la manera más básica, ahora continuaremos pero esta vez ya no obtendremos los usuarios desde XML como en:














Ahora vamos a obtener los usuarios desde un archivo de propiedades, para eso el XML anterior se reduce a:










Ojo que el archivo de propiedades lo podemos obtener desde el classpath de la aplicación(como en el ejemplo anterior)
o desde un archivo externo a la aplicación como en:









De esta manera podemos modificar el archivo de propiedades sin desempaquetar el EAR o WAR de la aplicación


El archivo de propiedades que contiene a los usuarios es bien simple, le especificamos el usuario, password, los roles o perfiles y si está habilitado o no:


#usuario=password,rol1[,rolN][,enabled|disabled]
ccacique1=pass1,PERFIL_ADMINISTRADOR,disabled
ccacique2=pass2,PERFIL_SUPERVISOR,enabled
ccacique3=pass3,PERFIL_ADMINISTRADOR,PERFIL_SUPERVISOR,enabled


La gestión de usuarios mediante archivos(sea en XML o en properties) no es apropiado en un entorno de producción donde pueden interactuar cientos o miles de usuarios, por lo que spring security nos proporciona una manera de obtener dichos usuarios desde la base de datos:


Para implementar la gestión de usuarios mediante una base de datos con spring security debemos de hacer lo siguiente:


  1. Implementar un proveedor de usuarios.

  2. El proveedor de usuarios debe de implementar la interface org.springframework.security.core.userdetails.UserDetailsService

  3. La interface anterior obliga a definir el método public UserDetails loadUserByUsername(String username), por lo que debemos de implementarlo

  4. El método anterior retorna un objeto de la clase org.springframework.security.core.userdetails.UserDetails, esta clase define campos de autenticación de usuarios simple como nombre de usuario, password, si el usuario está bloqueado y los perfiles asociados a este usuario.

  5. Colocar la referencia al proveedor de usuarios en donde usuarioService es mi proveedor de usuarios



Veamos la implementación del gestor de usuarios:



package pe.com.slcsccy.pc.springsecurity.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import pe.com.slcsccy.pc.springsecurity.dao.UsuarioDAO;
import pe.com.slcsccy.pc.springsecurity.model.Usuario;

@Service("usuarioService")
public class UsuarioServiceImpl implements UserDetailsService{
@Autowired
private UsuarioDAO usuarioDAO;

@Override
public UserDetails loadUserByUsername(String username)
throws UsernameNotFoundException, DataAccessException {
Usuario usuario = null;
List usuarios = usuarioDAO.buscarUsuarioPorCodigo(username);
if(usuarios.size()==0)throw new UsernameNotFoundException("Usuario no existe.");
else{
usuario = usuarios.get(0);
usuario.setPerfiles(usuarioDAO.buscarPerfilesDeUsuarioPorCodigo(username));
return usuario;
}
}
}


El proveedor de usuarios hace uso de un objeto de acceso a datos, que lo he implementado con spring jdbc:


package pe.com.slcsccy.pc.springsecurity.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.security.core.GrantedAuthority;

import pe.com.slcsccy.pc.springsecurity.model.Perfil;
import pe.com.slcsccy.pc.springsecurity.model.Usuario;

public class UsuarioDAOImpl implements UsuarioDAO {

private JdbcTemplate jdbcTemplate;

public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}

@SuppressWarnings("unchecked")
@Override
public List buscarUsuarioPorCodigo(String codigo) {
return jdbcTemplate.query("select * from usuario where cod_usuario = ? ", new RowMapper() {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Usuario usuario = new Usuario();
usuario.setUsername(rs.getString("cod_usuario"));
usuario.setPassword(rs.getString("des_password"));
usuario.setAccountNonExpired(rs.getString("in_cuenta_expirada").equals("N")?true:false);
usuario.setAccountNonLocked(rs.getString("in_cuenta_bloqueada").equals("N")?true:false);
usuario.setCredentialsNonExpired(rs.getString("in_credencial_expirada").equals("N")?true:false);
usuario.setEnabled(rs.getString("in_habilitado").equals("S")?true:false);
return usuario;
}
},codigo);
}

@SuppressWarnings("unchecked")
@Override
public List buscarPerfilesDeUsuarioPorCodigo(String codigo) {
return jdbcTemplate.query("select cod_perfil from usuario_perfil where cod_usuario = ? ", new RowMapper() {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Perfil perfil = new Perfil();
perfil.setNombrePerfil(rs.getString("cod_perfil"));
return perfil;
}
},codigo);
}
}


El acceso a los datos se realiza mediante un modelo de dominio de usuarios y de perfiles siguiente:

Usuario.java


package pe.com.slcsccy.pc.springsecurity.model;
import java.util.Collection;
import java.util.List;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
public class Usuario implements UserDetails{

private static final long serialVersionUID = -4993799715730712001L;

private List perfiles;
private String username;
private String password;
private boolean accountNonExpired;
private boolean accountNonLocked;
private boolean credentialsNonExpired;
private boolean enabled;

public Collection getPerfiles() {
return perfiles;
}

@SuppressWarnings("unchecked")
public void setPerfiles(List perfiles) {
this.perfiles = (List) perfiles;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public boolean isAccountNonExpired() {
return accountNonExpired;
}
public void setAccountNonExpired(boolean accountNonExpired) {
this.accountNonExpired = accountNonExpired;
}
public boolean isAccountNonLocked() {
return accountNonLocked;
}
public void setAccountNonLocked(boolean accountNonLocked) {
this.accountNonLocked = accountNonLocked;
}
public boolean isCredentialsNonExpired() {
return credentialsNonExpired;
}
public void setCredentialsNonExpired(boolean credentialsNonExpired) {
this.credentialsNonExpired = credentialsNonExpired;
}
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public Collection getAuthorities() {
return perfiles;
}

}



Perfil.java


package pe.com.slcsccy.pc.springsecurity.model;
import org.springframework.security.core.GrantedAuthority;
public class Perfil implements GrantedAuthority{

private static final long serialVersionUID = 1L;
private String nombrePerfil;

public Perfil(){
}

public String getNombrePerfil() {
return nombrePerfil;
}

public void setNombrePerfil(String nombrePerfil) {
this.nombrePerfil = nombrePerfil;
}

@Override
public String getAuthority() {
return this.nombrePerfil;
}

}


El modelo de dominio y el objeto de acceso a datos colaboran entre sí para conectarse y dar soporte a los datos de una base de datos Oracle que tiene la siguiente estructura e información:


create user springsecurity identified by springsecurity account unlock;
grant resource,connect to springsecurity;

create table springsecurity.usuario(
cod_usuario varchar2(40) not null,
des_password varchar2(40) not null,
in_cuenta_expirada char(1) default 'N' not null ,
in_cuenta_bloqueada char(1) default 'N' not null ,
in_credencial_expirada char(1) default 'N' not null ,
in_habilitado char(1) default 'S' not null ,
primary key(cod_usuario)
);

create table springsecurity.perfil(
cod_perfil varchar2(40) not null,
des_perfil varchar2(40) not null,
primary key(cod_perfil)
);

create table springsecurity.usuario_perfil(
cod_usuario varchar2(40),
cod_perfil varchar2(40),
primary key(cod_usuario,cod_perfil),
foreign key(cod_usuario) references springsecurity.usuario(cod_usuario),
foreign key(cod_perfil) references springsecurity.perfil(cod_perfil)
);

insert into springsecurity.perfil values('PERFIL_ADMINISTRADOR','PERFIL DE ADMINISTRADOR');
insert into springsecurity.perfil values('PERFIL_SUPERVISOR','PERFIL DE SUPERVISOR');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique1','pass1');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique2','pass2');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique3','pass3');
insert into springsecurity.usuario(cod_usuario,des_password) values('ccacique4','pass4');
insert into springsecurity.usuario_perfil(cod_usuario,cod_perfil) values('ccacique1','PERFIL_ADMINISTRADOR');
insert into springsecurity.usuario_perfil(cod_usuario,cod_perfil) values('ccacique2','PERFIL_SUPERVISOR');



Con la estructura anterior ya podemos gestionar nuestros usuarios con soporte de spring security.


El contenedor de beans de spring security quedaría de la siguiente manera:



xmlns:b="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">


access-decision-manager-ref="accessDecisionManager">







login-page="/login.jsp"
default-target-url="/public/mostrarFormulario.htm"
authentication-failure-url="/loginerror.jsp"/>





invalidate-session="true"
logout-url="/public/terminarSesion.htm"
logout-success-url="/logout.jsp" />













































El proyecto completo te lo puedes bajar desde AQUI

sábado, 7 de agosto de 2010

Spring Security Mediante XML

Hola que tal, ahora les voy a presentar una pequeña implementación de spring security, el caso de uso a implementar es el siguiente:

Permitir que la aplicación calculadora(formulario simple de ingreso de operandos y selección de operación) sea accedida mediante usuarios que previamente se han autenticado o que tambien sea accedida en forma anónima al seleccionar una lista de opciones.

1. Lo primero que tenemos que hacer es configurar un filtro en el descriptor de despliegue de nuestra aplicación web de la siguiente manera:



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_2_5.xsd">



calculadora-controller
org.springframework.web.servlet.DispatcherServlet
1




calculadora-controller
*.htm





springSecurityFilterChain
org.springframework.web.filter.DelegatingFilterProxy




springSecurityFilterChain
/*




org.springframework.web.context.ContextLoaderListener




contextConfigLocation

/WEB-INF/calculadora-security.xml





index.jsp




403
/sinacceso.jsp






2. Ahora vamos a configurar los beans que conforman el controller de la aplicación, mediante anotaciones. El flujo de control de la aplicación es simple: define un archivo de inicio index.jsp que redirecciona hacia /public/iniciar.htm está ruta será interceptada por el filtro de spring security y como la URL es pública no necesitará de una autenticación, después llegará hacia el controller: @Controller public class CalculadoraController {...} que ha mapeado la URL solicitada y la redirigirá hacia la página jsp opciones.jsp. En la página de opciones es donde se prueba la seguridad implementanda mediante spring, en esta página listo 5 opciones de acceso(todas me conducen al formulario de la calculadora), la primera opción accesa al formulario en forma anónima, las 4 siguientes requieren una autenticación, si el usuario aún no se a autenticado es redirigido hacia login.jsp para que se autentique, si el usuario ingresa sus credenciales(usuario y passwords) y genera un error entonces es redirigido hacia loginerror.jsp, si el usuario se autentica satisfactoriamente pero no tiene permiso entonces generará un error 403(acceso denegado, el cual es definido en el descriptor de despliegue)



xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:security="http://www.springframework.org/schema/security"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">





p:basename="mensajes"/>

p:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/>






3. Ahora lo más importante, la definición del contexto de seguridad mediante spring:



xmlns:b="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">


access-decision-manager-ref="accessDecisionManager">







login-page="/login.jsp"
default-target-url="/public/mostrarFormulario.htm"
authentication-failure-url="/loginerror.jsp"/>





invalidate-session="true"
logout-url="/public/terminarSesion.htm"
logout-success-url="/logout.jsp" />










































El proyecto completo te lo puedes bajar desde AQUI