Autor: raidentrance

Soy @raidentrance en Twitter y en Github, soy egresado de la Facultad de Ingeniería de la UNAM, cuento con 8 certificaciones en diferentes áreas del desarrollo de software, me gustan las cervezas y soy Geek.

Mi experiencia con las certificaciones en TI

por raidentrance, posted in Español

He leído multiples debates en diferentes medios sobre si el hecho de obtener una certificación te da un mayor valor como ingeniero o no. A continuación listaré de forma objetiva mi opinión al respecto.

Mi situación

Soy un Ingeniero en Software de México con 9 años de experiencia en el desarrollo de software y he conseguido las siguientes certificaciones:

  • Oracle Certified Professional, Java SE 6 Programmer
  • IBM Certified Academic Associate – DB2 9 Database and Application Fundamentals
  • Oracle Certified Professional, Java EE 5 Web Component Developer
  • Oracle Database SQL Expert
  • AWS Certified Solutions Architect
  • AWS Certified Developer – Associate
  • Scrum Master Certified
  • Spring Professional v5.0

Dado lo anterior considero que soy una voz autorizada para hablar respecto a este tema y mencionaré ventajas, desventajas, inversión, consejos y una opinión personal al respecto.

Desventajas de las certificaciones en TI

No todo lo que tiene que ver con certificaciones es algo bueno, a continuación se muestran algunos de los puntos más importantes.

actualización

Cada día se liberan nuevos frameworks, herramientas y tecnologías, esto hace que sea muy complejo crear un examen de certificación para cada una y que este se mantenga actualizado en todo momento.

CURSOS enfocados en “PASAR EL EXAMEN”

El objetivo de un curso para acreditar un examen de certificación es aprender una tecnología a profundidad y que estos conocimientos sean suficientes para pasar el examen de certificación.

El problema es que muchas empresas imparten cursos enfocados en “PASAR EL EXAMEN” a través de exámenes de prueba similares al real y no en aprender la tecnología. Esto hace que se empiece a perder la credibilidad dado que al entrevistar a candidatos con certificaciones se nota que no cuentan con los conocimientos suficientes sobre el tema.

mantenerlas actualizadas es muy costoso

Las certificaciones tienen una fecha de vencimiento y diferentes niveles lo cual hace que sea muy complejo en términos de tiempo y económicos llegar a un nivel alto con todas las certificaciones actualizadas a la versión más reciente.

certificaciones con poca credibilidad

Al no existir un estándar sobre las certificaciones que son oficiales y quien puede o no emitir una certificación, existen muchas con poca credibilidad que desacreditan a todas.

ARROGANCIA

Muchas personas piensan que una vez que se consigue la certificación no hay necesidad de seguir aprendiendo o que el hecho de tenerla le da la razón en cualquier tema relacionado.

Enfoque de quien emite la certificación

Algunas veces existen múltiples formas de resolver un problema y en los exámenes de certificación tienden a evaluar el enfoque que beneficia a la empresa que emite la certificación.

Ventajas de las certificaciones en ti

A continuación listaré los beneficios que considero que tiene el conseguir una certificación:

Interés en el tema

Tratar de conseguir una certificación en TI demuestra que tienes un interés real en aprender una tecnología y que no es algún deseo vago que se te pasará en un par de semanas.

Las personas apasionadas por la tecnología, en algún momento, se han planteado la posibilidad de presentar un examen de certificación. El interés es demostrado desde el punto que no se trata solo de una decisión, sino que existe una inversión económica, la cual te compromete a, por lo menos, leer un poco más a profundidad sobre el tema.

Disciplina

Conseguir una certificación requiere de mucha disciplina. Existe un porcentaje alto de personas a las que le gustaría presentar un examen de certificación, pero al final no toman la decisión de hacerlo o incluso lo pagan pero al no tener la disciplina para estudiar y estar listos para el examen, deciden no presentarlo o no lo acreditan.

TALENTO

Acreditar un examen de certificación requiere de talento y, sin importar si se tomó un curso, se compró un libro o es solo por experiencia, suelen ser complicados y normalmente en inglés lo cual lo complica para muchos de los desarrolladores.

ENFOQUE EN TEMAS IMPORTANTES

Cuando se busca aprender una nueva tecnología, algunas veces es complejo definir el punto de inicio y los temas importantes que se deberían aprender. Una certificación es de mucha utilidad al definir los temas específicos que se deben conocer de una forma estructurada para considerarte en cierto nivel.

Diferenciador

Tener certificaciones no te hace mejor o peor que alguien que no las tiene, pero, si en un proceso de selección te encuentras a la par de otro candidato, este puede ser un punto que juegue a tu favor.

El aprendizaje

La mayor ventaja de conseguir una certificación es el aprendizaje obtenido, dado el tiempo y esfuerzo que se requiere para obtenerla.

Me gustaría agregar en tono personal que es muy satisfactorio y es un gran logro.

Reconocimiento a nivel internacional

Las certificaciones oficiales son una buena forma de definir un nivel de conocimiento sobre un tema que es reconocido a nivel internacional. Esto beneficia mucho a las personas que buscan oportunidades fuera de su país de origen.

Tolerancia a la frustración

Es muy probable que a la mitad del proceso de aprendizaje te des cuenta que es más complejo de lo que pensabas o que incluso no pases el examen en tu primera oportunidad. Si logras conseguir tu examen hablará de cómo lograste superar esa frustración.

No existe requerimiento con respecto a edad o nivel de estudios

No es necesario contar con cierta edad o con algún nivel de estudios para presentar un examen de certificación y demostrar tus conocimientos de tecnología. Esto es un gran beneficio para las personas que se quieren enfocar en la tecnología desde una edad corta.

Inversión

Certificarte de forma constante requiere inversión. A continuación algunos gastos que debes considerar:

  • Costo del examen de certificación
  • Costo del o los libros
  • Costo de curso, en caso de que lo necesites
  • Simuladores

Si piensas obtener más de una certificación, este costo se incrementa de forma notable, pero consideremos que la educación siempre es una buena inversión.

Consejos

A continuación algunos consejos para las personas que se encuentran en el proceso de aprendizaje de algunas tecnologías:

  • Aprende la tecnología que te guste sin importar si existe o no un examen de certificación.
  • Si la tecnología no tiene alguna certificación trata de aprenderla como si la tuviera. Aprende a profundidad cualquier cosa.
  • No tienes que certificarte para cada tecnología, elige bien. A continuación algunos puntos para decidir en que certificarte:
    • Muy recomendable hacerlo para los fundamentos de una tecnología: Si eres programador el lenguaje de programación que utilizas es la base de todo lo que vas a hacer, en ese caso es muy recomendable que lo hagas.
    • Una tecnología que consideras que utilizarás: Si consideras certificarte en algún tema que crees que no utilizarás en tu trabajo o en un futuro cercano, tal vez no es la mejor idea certificarte dado que es posible que olvides los detalles específicos.
    • Siempre es mejor ser un experto: Conocer un poco de todo es muy bueno, pero es mejor que en lugar de que obtengas la certificación básica de 10 lenguajes de programación trates de llegar a ser un experto en uno, eso te ayudará a crecer más como profesional.
  • Tener una certificación no te hace mejor que un desarrollador que no está certificado. Existen muchos programadores a los que no les llama la atención certificarse pero aún así les gusta aprender las tecnologías a detalle.
  • Reprobar un examen de certificación no está mal: Entiende que son exámenes complejos y la posibilidad de que esto suceda es alta, así que tómalo como un motivador para pasarlo en la próxima oportunidad.
  • ¡No es imposible!. Algunas personas se desmotivan pensando que es algo difícil y se vencen antes de hacer el intento. Si eres disciplinado y aferrado ten por seguro que conseguirás acreditar cualquier examen.
  • Busca los libros oficiales, Un libro normal no será suficiente para acreditar el examen, siempre busca en primer lugar si existe un libro oficial, de este modo estarás seguro que lo que estas estudiando cubre los temas correctos. Existen certificaciones avanzadas que no cuentan con un libro en específico, en este caso busca en blogs el material recomendado y utilízalo.
  • Si tienes dudas entre intentarlo o no, solo hazlo y averígualo por ti mismo.
  • Si tomas un curso de certificación y desde el principio te das cuenta que se enfocan 100% en exámenes de prueba y no en que aprendas la tecnología, salte desde el primer día y exige una devolución de tu dinero.
  • Paga el examen antes de estudiar. Muchas veces decimos: “primero voy a estudiar para el examen y ya que me sienta listo, lo presentaré”; el problema es que aveces ese momento no llega, mi recomendación total es, si ya decidiste que presentarás el examen, págalo desde un principio, eso te ayudará a disciplinarte porque “ya lo pagaste y ahora lo tienes que hacer”.
  • Evita posponerlo. Si hiciste un compromiso contigo mismo de hacer el examen en una fecha, trata de no cambiarla a menos que sea algo muy importante, si no esto se convertirá en un vicio y nunca estudiarás con seriedad (aparte que hay un número limitado de veces que los puedes posponer).
  • Tómalo como un reto personal más que como una obligación. Si lo ves como una obligación te costará más trabajo concentrarte, te recomiendo que lo veas como un gran reto y al final si lo consigues será más gratificante.
  • No trates de obtener una certificación solo por dinero. Si obtienes una certificación solo por dinero es muy probable que pases haciendo algo que no te gusta el resto de tu vida, haz lo que te guste y hazlo bien.
  • No tengas miedo de invertir en aprendizaje. Con o sin certificación, es importante que sepas que todo lo que inviertas en aprendizaje muy probablemente se multiplicará, así que invierte sin miedo.

Mi caso personal

Para dar una conclusión sobre este tema me gustaría hablar sobre mi experiencia. En el 2011 conseguí mi primera certificación sin saber nada de inglés, eso me dio mucha confianza para romper todos los paradigmas de lo difícil o de las limitantes del idioma.

Actualmente tengo una posición importante en una gran empresa, pero no considero que todo esto se deba solo a una lista de certificaciones, si no al gusto que tengo por la programación y a nunca quedarme con la duda sobre algo.

Mi consejo personal es que si estas iniciando y te gustaría ser un gran ingeniero aprendas lo que te guste, busques ser profesional en algo y nunca te quedes quieto, si sigues estos puntos es muy probable que tendrás una carrera exitosa como ingeniero.

Si tienes alguna duda ve a nuestras redes sociales y coméntanos si es un tema de tu interés y si te gustaría que profundicemos en algo.

Si te gusta el contenido y quieres enterarte cuando realicemos un post nuevo síguenos en nuestras redes sociales.

Autor: Alejandro Agapito Bautista
Twitter: @raidentrance
Contacto:raidentrance@gmail.com

Clase de programación desde cero con Java

Destacado por raidentrance, posted in Español

El objetivo de esta clase es que los estudiantes aprendan los primeros pasos con Java y aprovechen el tiempo durante la cuarentena.

FECHA y hora

Lunes 27 de abril, 2020 a las 19:00 CST

Duración: 2 horas

Instructor

El instructor será Alejandro Agapito Bautista quien es Technical Expert en Walmart, cuenta las siguientes certificaciones en diferentes áreas del desarrollo de software:

  • Spring Framework 5 professional
  • AWS Certified Solutions Architect
  • AWS Certified Developer – Associate
  • Scrum Master Certified
  • Oracle Database SQL Expert
  • Oracle Certified Professional, Java EE 5 Web Component Developer
  • Oracle Certified Professional, Java SE 6 Programmer
  • IBM Certified Academic Associate – DB2 9 Database and Application Fundamentals

REQUISITOS

Para poder participar en nuestra clase en línea deberás cumplir con los siguientes requisitos:

Dependiendo de la participación que se tenga tomaremos la decisión de continuar con este tipo de clases, así que te invitamos a participar y poner todo de tu parte para aprender.

INSCRIPCIÓN

Solo recibirán el link para unirse a la sesión los estudiantes que cumplan los requisitos indicados.

Spring framework 5 : AOP Around Advice

por raidentrance, posted in Español

Como vimos en el post pasado https://devs4j.com/2019/02/28/spring-framework-5-aop-conceptos-basicos/ existen diferentes tipos de advices, en este post nos enfocaremos en Around Advice.

Para poder seguir estos ejemplos es necesario crear un proyecto spring boot simple.

Creación de un servicio de spring

El primer paso para entender como funcionan los advices será crear un servicio de spring, este objeto será nuestro Target object.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * @author raidentrance
 *
 */
@Service
public class HelloWorldService {

	private static final Logger log = LoggerFactory.getLogger(HelloWorldService.class);

	public void print() {
		log.info("Hello world");
	}

}

Como vemos nuestro servicio es solo una clase llamada HelloWorldService con un método llamado print().

Around Advice

En este ejemplo interceptaremos las peticiones a la clase HelloWorldService en su método print utilizando un Around Advice, veamos el siguiente ejemplo:

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @author raidentrance
 *
 */
@Aspect
@Component
public class AroundAdviceExample {
	private static final Logger log = LoggerFactory.getLogger(AroundAdviceExample.class);

	@Around("execution(* com.devs4j.service.HelloWorldService.*(..))")
	public Object logAround(ProceedingJoinPoint proceedingJoinPoint) {
		log.info("before advice example");
		Object result = null;
		try {
			result = proceedingJoinPoint.proceed();
		} catch (Throwable e) {
			log.info("There is an exception ", e);
		}
		log.info("after advice example");
		return result;
	}
}

Del código anterior podemos analizar los siguientes puntos:

  • La clase esta anotada con @Component y @Aspect esto permite a spring identificarlo como un bean y como un aspecto.
  • La anotación @Around nos permite utilizar un Around advice.
  • Los advices reciben como parámetro un Pointcut el cual define los objetos que serán afectados por el Advice (Explicaremos Pointcut expression language en otro post).
  • El método recibe como parámetro un objeto que implementa la interfaz JoinPoint, esto nos permite acceder a información del JoinPoint que se interceptó.
  • Lo único que hace nuestro aspecto es imprimir el mensaje before advice example, después ejecuta el método y al final imprime after advice example
  • Los around advices interceptan la petición y deciden si ejecutar o no, esto nos permite hacer algo antes de la ejecución, después ejecutar o no el método y al final nos permite de igual modo realizar una acción.

Una vez que tenemos listo nuestro aspecto el siguiente paso será probarlo, para esto crearemos la siguiente clase:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.devs4j.service.HelloWorldService;

@SpringBootApplication
public class Devs4jSpringAopApplication {

	public static void main(String[] args) {
		ConfigurableApplicationContext applicationContext = SpringApplication.run(Devs4jSpringAopApplication.class,
				args);
		HelloWorldService helloWorldService = applicationContext.getBean(HelloWorldService.class);
		helloWorldService.print();
	}

}

Del código anterior podemos analizar los siguientes puntos:

  • Obtenemos un bean del tipo HelloWorldService
  • Ejecutamos el método print()

Salida:

2019-03-29 09:52:40.934  INFO 75349 --- [           main] com.devs4j.Devs4jSpringAopApplication    : Started Devs4jSpringAopApplication in 0.952 seconds (JVM running for 1.265)
2019-03-29 09:52:40.938  INFO 75349 --- [           main] com.devs4j.aop.AroundAdviceExample       : before advice example
2019-03-29 09:52:40.947  INFO 75349 --- [           main] com.devs4j.service.HelloWorldService     : Hello world
2019-03-29 09:52:40.947  INFO 75349 --- [           main] com.devs4j.aop.AroundAdviceExample       : after advice example

Como vemos se imprimió el mensaje before advice example después se imprimió Hello world y al final after advice example esto nos indica que el aspecto que utiliza around advice se ejecuta antes y permite realizar acciones después del método print.

Para estar al pendiente sobre nuestro contenido nuevo síguenos en nuestras redes sociales https://www.facebook.com/devs4j/ y https://twitter.com/devs4j.

Spring framework 5 : AOP After throwing Advice

por raidentrance, posted in Español

Como vimos en el post pasado https://devs4j.com/2019/02/28/spring-framework-5-aop-conceptos-basicos/ existen diferentes tipos de advices, en este post nos enfocaremos en After throwing Advice.

Para poder seguir estos ejemplos es necesario crear un proyecto spring boot simple.

Creación de un servicio de spring

El primer paso para entender como funcionan los advices será crear un servicio de spring, este objeto será nuestro Target object.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * @author raidentrance
 *
 */
@Service
public class HelloWorldService {

	private static final Logger log = LoggerFactory.getLogger(HelloWorldService.class);

	public void print() {
		log.info("Hello world");
		throw new IllegalStateException();
	}

}

Como vemos nuestro servicio es solo una clase llamada HelloWorldService con un método llamado print().

After throwing Advice

En este ejemplo interceptaremos las peticiones a la clase HelloWorldService en su método print utilizando un After Throwing Advice, veamos el siguiente ejemplo:

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @author raidentrance
 *
 */
@Aspect
@Component
public class AfterThrowingAdviceExample {
	
	private static final Logger log = LoggerFactory.getLogger(AfterThrowingAdviceExample.class);

	@AfterThrowing("execution(* com.devs4j.service.HelloWorldService.*(..))")
	public void logAfterThrowing(JoinPoint joinPoint) {
		log.info("After throwing example");
	}
}

Del código anterior podemos analizar los siguientes puntos:

  • La clase esta anotada con @Component y @Aspect esto permite a spring identificarlo como un bean y como un aspecto.
  • La anotación @AfterThrowing nos permite utilizar un After throwing advice.
  • Los advices reciben como parámetro un Pointcut el cual define los objetos que serán afectados por el Advice (Explicaremos Pointcut expression language en otro post).
  • El método recibe como parámetro un objeto que implementa la interfaz JoinPoint, esto nos permite acceder a información del JoinPoint que se interceptó.
  • Lo único que hace nuestro aspecto es imprimir el mensaje After throwing example
  • Los Advices After throwing se ejecutan después de que se ejecutó el método interceptado siempre y cuando haya habido una excepción.

Una vez que tenemos listo nuestro aspecto el siguiente paso será probarlo, para esto crearemos la siguiente clase:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.devs4j.service.HelloWorldService;

@SpringBootApplication
public class Devs4jSpringAopApplication {

	public static void main(String[] args) {
		ConfigurableApplicationContext applicationContext = SpringApplication.run(Devs4jSpringAopApplication.class,
				args);
		HelloWorldService helloWorldService = applicationContext.getBean(HelloWorldService.class);
		helloWorldService.print();
	}

}

Del código anterior podemos analizar los siguientes puntos:

  • Obtenemos un bean del tipo HelloWorldService
  • Ejecutamos el método print()

Salida:

2019-03-01 12:53:58.076  INFO 76486 --- [           main] com.devs4j.service.HelloWorldService     : Hello world
2019-03-01 12:53:58.078  INFO 76486 --- [           main] c.devs4j.aop.AfterThrowingAdviceExample  : After throwing example
Exception in thread "main" java.lang.IllegalStateException
	at com.devs4j.service.HelloWorldService.print(HelloWorldService.java:21)
	at com.devs4j.service.HelloWorldService$$FastClassBySpringCGLIB$$c594d12f.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:749)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:62)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:93)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:688)
	at com.devs4j.service.HelloWorldService$$EnhancerBySpringCGLIB$$28652767.print(<generated>)
	at com.devs4j.Devs4jSpringAopApplication.main(Devs4jSpringAopApplication.java:16)

Como vemos se imprimió el mensaje After throwing example después de Hello world, esto nos indica que el aspecto que utiliza after throwing advice se ejecuta después del método print debido a que este arroja una IllegalStateException.

Para estar al pendiente sobre nuestro contenido nuevo síguenos en nuestras redes sociales https://www.facebook.com/devs4j/ y https://twitter.com/devs4j.

Autor: Alejandro Agapito Bautista
Twitter: @raidentrance
Contacto:raidentrance@gmail.com

Spring framework 5 : AOP After returning Advice

por raidentrance, posted in Español

Como vimos en el post pasado https://devs4j.com/2019/02/28/spring-framework-5-aop-conceptos-basicos/ existen diferentes tipos de advices, en este post nos enfocaremos en After returning Advice.

Para poder seguir estos ejemplos es necesario crear un proyecto spring boot simple.

Creación de un servicio de spring

El primer paso para entender como funcionan los advices será crear un servicio de spring, este objeto será nuestro Target object.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * @author raidentrance
 *
 */
@Service
public class HelloWorldService {

	private static final Logger log = LoggerFactory.getLogger(HelloWorldService.class);

	public void print() {
		log.info("Hello world");
	}

}

Como vemos nuestro servicio es solo una clase llamada HelloWorldService con un método llamado print().

After returning Advice

En este ejemplo interceptaremos las peticiones a la clase HelloWorldService en su método print utilizando un After Returning Advice, veamos el siguiente ejemplo:

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @author raidentrance
 *
 */
@Aspect
@Component
public class AfterReturningAdviceExample {

	private static final Logger log = LoggerFactory.getLogger(AfterReturningAdviceExample.class);

	@AfterReturning("execution(* com.devs4j.service.HelloWorldService.*(..))")
	public void logAfterReturning(JoinPoint joinPoint) {
		log.info("After returning example");
	}

}

Del código anterior podemos analizar los siguientes puntos:

  • La clase esta anotada con @Component y @Aspect esto permite a spring identificarlo como un bean y como un aspecto.
  • La anotación @AfterReturning nos permite utilizar un After returning advice.
  • Los advices reciben como parámetro un Pointcut el cual define los objetos que serán afectados por el Advice (Explicaremos Pointcut expression language en otro post).
  • El método recibe como parámetro un objeto que implementa la interfaz JoinPoint, esto nos permite acceder a información del JoinPoint que se interceptó.
  • Lo único que hace nuestro aspecto es imprimir el mensaje After returning example
  • Los Advices After returning se ejecutan después de que se ejecutó el método interceptado siempre y cuando no haya habido una excepción.

Una vez que tenemos listo nuestro aspecto el siguiente paso será probarlo, para esto crearemos la siguiente clase:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.devs4j.service.HelloWorldService;

@SpringBootApplication
public class Devs4jSpringAopApplication {

	public static void main(String[] args) {
		ConfigurableApplicationContext applicationContext = SpringApplication.run(Devs4jSpringAopApplication.class,
				args);
		HelloWorldService helloWorldService = applicationContext.getBean(HelloWorldService.class);
		helloWorldService.print();
	}

}

Del código anterior podemos analizar los siguientes puntos:

  • Obtenemos un bean del tipo HelloWorldService
  • Ejecutamos el método print()

Salida:

2019-03-01 10:57:37.307  INFO 72532 --- [           main] com.devs4j.service.HelloWorldService     : Hello world
2019-03-01 10:57:37.308  INFO 72532 --- [           main] c.d.aop.AfterReturningAdviceExample      : After returning example

Como vemos se imprimió el mensaje After returning example después de Hello world, esto nos indica que el aspecto que utiliza after returning advice se ejecuta después del método print que se invocó de la clase HelloWorldService.

Para estar al pendiente sobre nuestro contenido nuevo síguenos en nuestras redes sociales https://www.facebook.com/devs4j/ y https://twitter.com/devs4j.

Autor: Alejandro Agapito Bautista
Twitter: @raidentrance
Contacto:raidentrance@gmail.com

Spring framework 5 : AOP Before Advice

por raidentrance, posted in Español

Como vimos en el post pasado https://devs4j.com/2019/02/28/spring-framework-5-aop-conceptos-basicos/ existen diferentes tipos de advices, en este post nos enfocaremos en Before Advice.

Para poder seguir estos ejemplos es necesario crear un proyecto spring boot simple.

Creación de un servicio de spring

El primer paso para entender como funcionan los advices será crear un servicio de spring, este objeto será nuestro Target object.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * @author raidentrance
 *
 */
@Service
public class HelloWorldService {

	private static final Logger log = LoggerFactory.getLogger(HelloWorldService.class);

	public void print() {
		log.info("Hello world");
	}

}

Como vemos nuestro servicio es solo una clase llamada HelloWorldService con un método llamado print().

Before Advice

En este ejemplo interceptaremos las peticiones a la clase HelloWorldService en su método print utilizando un Before Advice, veamos el siguiente ejemplo:

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @author raidentrance
 *
 */
@Aspect
@Component
public class BeforeAdviceExample {

	private static final Logger log = LoggerFactory.getLogger(BeforeAdviceExample.class);

	@Before("execution(* com.devs4j.service.HelloWorldService.print*(..))")
	public void logBefore(JoinPoint joinPoint) {
		log.info("Before advice example");
	}
}

Del código anterior podemos analizar los siguientes puntos:

  • La clase esta anotada con @Component y @Aspect esto permite a spring identificarlo como un bean y como un aspecto.
  • La anotación @Before nos permite utilizar un Before advice.
  • Los advices reciben como parámetro un Pointcut el cual define los objetos que serán afectados por el Advice (Explicaremos Pointcut expression language en otro post).
  • El método recibe como parámetro un objeto que implementa la interfaz JoinPoint, esto nos permite acceder a información del JoinPoint que se interceptó.
  • Lo único que hace nuestro aspecto es imprimir el mensaje Before advice example

Una vez que tenemos listo nuestro aspecto el siguiente paso será probarlo, para esto crearemos la siguiente clase:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.devs4j.service.HelloWorldService;

@SpringBootApplication
public class Devs4jSpringAopApplication {

	public static void main(String[] args) {
		ConfigurableApplicationContext applicationContext = SpringApplication.run(Devs4jSpringAopApplication.class,
				args);
		HelloWorldService helloWorldService = applicationContext.getBean(HelloWorldService.class);
		helloWorldService.print();
	}

}

Del código anterior podemos analizar los siguientes puntos:

  • Obtenemos un bean del tipo HelloWorldService
  • Ejecutamos el método print()

Salida:

2019-03-01 10:35:26.624  INFO 71997 --- [           main] com.devs4j.aop.BeforeAdviceExample       : Before advice example
2019-03-01 10:35:26.632  INFO 71997 --- [           main] com.devs4j.service.HelloWorldService     : Hello world

Como vemos se imprimió el mensaje Before advice example antes de Hello world, esto nos indica que el aspecto que utiliza before advice se ejecuta antes del método print que se invocó de la clase HelloWorldService.

Para estar al pendiente sobre nuestro contenido nuevo síguenos en nuestras redes sociales https://www.facebook.com/devs4j/ y https://twitter.com/devs4j.

Autor: Alejandro Agapito Bautista
Twitter: @raidentrance
Contacto:raidentrance@gmail.com

Spring framework 5 : AOP Conceptos básicos

por raidentrance, posted in Español

AOP (Aspect oriented programming) es un paradigma de programación al igual que la POO (Programación orientada a objetos), en la POO el punto principal de la programación es un objeto mientras que en AOP es un aspecto.

Los aspectos nos ayudan a solucionar problemas llamados crosscutting concerns, para poder adentrarnos a esto primero debemos entender algunos conceptos básicos de AOP:

  • Aspect : Un aspecto es una preocupación o funcionalidad que se aplica a multiples clases, el logging es un buen ejemplo.
  • Join point : Un punto durante la ejecución de un programa como la ejecución de un método o el manejo de una excepción, en Spring Aop siempre será la ejecución de un método.
  • Advice : Será la acción a tomar en un join point específico, existen diferentes tipos de advice “around”, “before” y “after”, se pueden considerar como “interceptores” de nuestros join points.
  • Pointcut : Un predicado que junta un conjunto de join points, para definir este predicado se utiliza AspectJ pointcut expression language.
  • Target object : Un objeto advised por uno o más aspectos, como Spring Aop utiliza proxys este siempre será un objeto proxied.
  • Aop proxy : Un objeto creado por el framework Aop para dar el soporte Aop, en Spring Aop se utiliza proxies dinámicos a través de CGLIB.
  • Weaving : Es el enlace entre los aspectos y los objetos, este se puede hacer de diferentes formas, Spring Aop lo hace en tiempo de ejecución.

Tipos de Advices

Como se menciono anteriormente existen diferentes tipos de advices:

  • Before advice : Este advice se ejecuta antes del join point, no tiene la habilidad de detener la ejecución a menos de que arroje una excepción.
  • After returning : Este advice se ejecuta después del join point, no se ejecuta si hay una excepción.
  • After throwing : Este advise se ejecuta si el método termina por una excepción.
  • After finally : Este advise se ejecuta si el método termina su ejecución de forma normal o por una excepción.
  • Around advice : Este advise rodea la ejecución de un método, puede ejecutar su comportamiento antes, después o incluso si se produce una excepción. También es responsable de determinar si quiere o no proceder con la invocación del método.

Around advice es el advice más poderoso pero es el más general, por esto se recomienda utilizar el más especifico para resolver el problema que necesitamos.

Usos prácticos

Algunos usos prácticos para el uso de Spring Aop son :

  • Logging
  • Seguridad
  • Administración de transacciones
  • Monitoreo de performance
  • Caching
  • Manejo de errores

Para estar al pendiente sobre nuestro contenido nuevo síguenos en nuestras redes sociales https://www.facebook.com/devs4j/ y https://twitter.com/devs4j.

Autor: Alejandro Agapito Bautista
Twitter: @raidentrance
Contacto:raidentrance@gmail.com