Strange Patterns

10 January 2018

Event-Driven Architecture

From O'Reilly.

02 January 2018

Quartz Race Condition (in a cluster)

There is race condition (ABA problem) when using Quartz cluster.
This may be translate in the below stacktrace:

For a strategy coding should not happen, however under certain circumstances, it does. (in particular WebLogic & Oracle DB)

The workaround is to set the following property:

org.quartz.jobStore.acquireTriggersWithinLock=true

As established in the official documentation it shouldn't be necessary:

org.quartz.jobStore.acquireTriggersWithinLock
Whether or not the acquisition of next triggers to fire should occur within an explicit database lock. This was once necessary (in previous versions of Quartz) to avoid dead-locks with particular databases, but is no longer considered necessary, hence the default value is “false”.

27-dic-2017 12h04="" [See nested exception: java.sql.SQLIntegrityConstraintViolationException: ORA-00001: restricción única (USERS.QRTZ_TRIGGERS_PK) violada
].
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'quartzScheduler' defined in ServletContext resource [/WEB-INF/spring/root-context.xml]: Invocation of init method failed; nested exception is org.quartz.JobPersistenceException: Couldn't store trigger 'DEFAULT.cronTriggerUserNotificacion' for 'DEFAULT.complexJobDetailUserNotificacion' job:ORA-00001: restricción única (USERS.QRTZ_TRIGGERS_PK) violada
[See nested exception: java.sql.SQLIntegrityConstraintViolationException: ORA-00001: restricción única (USERS.QRTZ_TRIGGERS_PK) violada
]
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1578)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:545)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:305)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)
    Truncated. see log file for complete stacktrace

29 December 2017

O'reilly Architecture

From O'reilly Neal Ford & Mark Richards presentation. These are one of several interesting points:

Trends 2017

From infoq:

Now, we should see 2018 trends :)

21 December 2017

Garbage Collector incompatibilities

Conflicting collector combinations in option list; please refer to the release notes for the combinations allowed

I got the above error message after upgrading Eclipse Oxygen.

This is for GC options:

-XX:+UseParallelGC
# -XX:+UseG1GC

We cannot use both Garbage Collector at the same time... at least in this new version 4.7.2

https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/collectors.html

13 December 2017

Spring Singleton & Concurrency

A good post with Java champs about Singleton, concurrency, instance variables & static:

http://richardchesterwood.blogspot.cl/2011/03/using-sessions-in-spring-mvc-including.html

https://stackoverflow.com/questions/37595841/spring-scope-usage-for-instance-variables

@Scope(scopeName = BeanDefinition.SCOPE_PROTOTYPE, proxyMode = ScopedProxyMode.TARGET_CLASS)

https://coderanch.com/t/661307/framework/singleton-concurrent-access

https://docs.spring.io/spring/docs/3.0.0.M3/reference/html/ch04s04.html

05 December 2017

Datasource Sizing - Queuing Theory

To obtain the correct number for a connection Datasource pool, first, we may need to understand queue theory and have good observability of the data source itself and from there take decisions.

Said that I'd like to review once again the Little's law (from Queuing Theory)

L – average number of customers
λ – long-term average arrival rate
W – average time a request spends in a system

L : Número promedio de clientes en un sistema
λ : Número promedio de clientes que llegan al sistema por unidad de tiempo
W : Tiempo promedio de espera en un sistema

30 November 2017

Patrones de Diseño (en un año)

Se han utilizado diferentes patrones de diseño para diferentes necesidades, tal como, de arquitectura de componentes a nivel de servicios y de patrones de construcción OOP.

A continuación es la lista de los patrones de diseños usados:

- Descomposición de servicios para poder tener un buen limite de dominios (DDD, separation of concerns)

- @Domains: usado en la capa Rest donde está la implementación de POJOs

- Repository: donde está desacoplado la implementación de varios repositorios, dejando expuesta el mismo contrato a los cliente.

- @Service: capa Rest, tiene Patrón: Service-layer, en donde implementamos diferentes servicios para llamar, sean base datos pertenecientes a CDN o directamente como cliente al bus de servicios.

- @Controller: Rest, es el controller de springmvc, que es parte del patrón de diseño MVC, el cual dejamos claro el manejo del flujo del servicio rest

- Factory: todos los datasources utilizados vienen del contenedor de aplicaciones (Weblogic), y es una factoría de la cual nos abstraemos de la implementación (Oracle) y usamos la conexión entregada, la cual es reutilizada en las siguientes interacciones.

- DAO: pl-generator, librería que genera DAO automático desde la metadata de oracle y tenemos la interfaz (Façade) de los stored procedures de la base de datos, por directriz (generalmente en bancos) siempre accedemos a través de esos SP, y la librería gracias a esta encapsulación entregada por DAO podemos abstraernos de todo lo necesario de conexiones JDBC.

- SAL: Service Access Layer: Rest, patrón que viene desde la arquitectura SOA y tenemos implementada los diferentes servicios en un solo package.

- MVC: angular/rest. Usamos el patrón Model-View-Controller en nuestra solución. View es AngularJS, Controller y Model está implementado en Rest en las clases con anotaciones @Controller y Pojos, aprovechando la separación entregada por Spring

- API-Proxy: Usamos servicios Rest para todos los accesos desde front hacia OSB/DB. nunca se puede acceder directo desde Front, asi se usa api-proxy como interfaz.

- Aggregator: se utiliza en message-aggregator-rest para encapsular la implementación de del motor de envio de emails. De esta manera le damos más valor al request del envío del correo (Decorator) y tenemos un fachada (facade) para la implementación final.

- Connection Factory: JMS, todos los JMS utilizan un Connection Factory implementada por WLS. de esta manera se reutilizan las conexiones JMS.

- Prototype: en javascript para extender funciones y hacer honor al límite de 100 líneas por función (modular), se utiliza el patrón prototype.

- Database per service: notificaciones utiliza 1 schema por su solución, y no compartimos la base de datos con otros servicios, si alguien más necesita insertar datos estos deben hacerse a través un el api-proxy expuesto por notificaciones.

- Shared database (base datos compartida), existen schemas que son utilizados por varios servicios, tal como, session_cn.

- Log aggregation, se logea las transacciones y funcionalidades importantes de cada uno de los servicios en un log de aplicación que está configurado en cada uno de los dominios de WLS.

- Client-side UI composition. Cada aplicación puede tener componentes propios que están encapsulados en directivas angular. Estas directivas pueden ser reutilizadas por otras aplicaciones. El equipo de Diseño se preocupa de generar el esqueleto de las páginas, componiendo diferentes componentes UI.

- además utilizamos de varios patrones de diseño de más bajo nivel GoF: iterator, façade, singleton, Factory method pattern, Decorator, Builder, etc.

Java Performance

This is a summary post of good practices (many easy) to improve performance in your Java code:

use Apache commons-lang StringUtils.replace() instead String.replace(). The big difference is because Java replace() uses regexp which makes it more expensive immediately.
avoid regexp if possible (many times we use regexp and meanwhile a String.indexof() is enough). also, Apache commons lang: StringUtils.replace("hola\nmundo\n", "\n", "");
Compile once a Regexp Pattern: Pattern pattern_dst = Pattern.compile("destinationAddress\\\"\\:\\\"[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+\\\"");
Apache commons lang, now has separated packages for regexp methods, such us, replaceall().
on the same, String.split also has issues when it's not a simple character the splitter
avoid using Java7 UUID (there are other faster libraries for it) (randomness trends to be slow).
https://github.com/cowtowncoder/java-uuid-generator
https://github.com/jchambers/fast-uuid (* this looks interesting)
https://github.com/codahale/fast-uuid

Asynchronous Logging Parameterized Messages (log4j2) (Ring buffer - LMAX Disruptor)
Many logging libraries offer an API for logging parameterized messages. This enables application code to look something like this:
logger.debug("Entry number: {} is {}", i, entry[i]);
without API:

if (logger.isDebugEnabled()) {
    logger.debug("Entry number: " + i + " is " + entry[i].toString());
}

The best solution is placeholders and if{}

if (logger.isDebugEnabled()) {
    logger.debug("Entry number: {} is {}", i, entry[i]);
} 
lambda java8:
logger.trace("Some long-running operation returned {}", () -> expensiveOperation());

Jasper Reports has a lazy loading at init() :
JasperReportsContext jasperReportsContext = new SimpleJasperReportsContext();
LocalJasperReportsContext localJasperReportsContext = new LocalJasperReportsContext(jasperReportsContext);
localJasperReportsContext.setClassLoader(this.getClass().getClassLoader());
StringBuilder or StringBuffer over String (for concatenation)
Primitive over wrapper, such us, Integer, Double etc, ie:
The Integer class wraps a value of the primitive type int in an object. An object of type Integer contains a single field whose type is int.
If you need an object instead, then use Integer.valueOf(), Long.valueOf()
Sorted of sorted List Java sorted ??? (Big Theta!)
String concatenating one line, it's not a problem
BigInteger & BigDecimal are expensive. (avoid)
Cache database connections. Object pooling. Apache common pool, Fast Object Pool, Vibur Object Pool
Tune fetchSize when querying a big number of rows from DB. (default is 10, which makes it slow)
Mapper Objects: use MapStruct (fastest).
log4j contention when writing to log file (async, buffer, network as a solution)
exceptions are "expensive"
Timeouts! (trigger'm!)
Socket_timeouts TCP_NODELAY, SO_SNDBUF, SO_RCVBUF, HTTP, JAX-WS, RestTemplate, JDBC timeouts :P
Thread synchronized (as seen on log4j2), blocking java monitor
HTTP 1.1 instead 1.0 (keep-alive)
Data source sizing
PMD has several performance rules: (among others)
Don’t create instances of already existing BigInteger (BigInteger.ZERO, BigInteger.ONE)
Avoid instantiating Boolean objects; you can reference Boolean.TRUE, Boolean.FALSE.
Most of PMD, checkstyles rules are embedded at sonarqube.
Jackson ObjectMapper must be reused (it's thread-safe). It is expensive.(use 2.8.7+ by race condition). Singleton, static or Object pooling (see above).
CompletableFuture uses a forkjoin thread pool, which is a thread pool shared between all CompletableFutures and all parallel streams.
https://dzone.com/articles/concurrency-in-action-using-javas-completable-futu
https://github.com/devwebcl/async-springmvc-poc
Java 8 parallel streams pitfall
https://www.baeldung.com/java-8-parallel-streams-custom-threadpool https://medium.com/@michaelbespalov/parallel-stream-pitfalls-and-how-to-avoid-them-91f11808a16
JVM CPU measure. It may be expensive for some JVM
Every time you make something "static", consider if you want to make it "final" too. In most cases, you do. "static final"-s are much more optimize-able. https://t.co/Xm0YgDUTtL (from @shipilev)
Netty is a popular asynch framework, but it can suffer of OOM: io.netty.maxDirectMemory
DO NOT use java 11 (~30% slower)
XML parsers: SAX <= JAXB << DOM (ms).
However jaxb es less complex than SAX for coding.
XML streaming based: StAX << SAX/XOM

try-with-resources

A known, and now kind of old feature of Java 7, but still isn't as popular as we wish.

Straightforward (and easy) implementation, where you need to declare resources (File, Stream) into parenthesis of "try" keyword:

private static void printFileJava7() throws IOException {

    try(InputStream input = new FileInputStream("hola.txt")) {

        int data = input.read();
        while(data != -1){
            System.out.print((char) data);
            data = input.read();
        }
    }
}

And JVM will have the responsibility to close those resources.

Beware: that the object in try() must implement AutoCloseable.

More info:

https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html

http://tutorials.jenkov.com/java-exception-handling/try-with-resources.html

https://www.mkyong.com/java/try-with-resources-example-in-jdk-7/