SivaLabs

Spring provides a nice abstraction on top of the JDBC API using JdbcTemplate and also provides great transaction management capabilities using an annotation-based approach.

In my previous post, Why SpringBoot?, we looked at how to create a Spring Boot application. But you may or may not understand what is going on behind the scenes. You may want to understand the magic behind Spring Boot’s AutoConfiguration.

Spring is a very popular Java-based framework for building web and enterprise applications. Unlike many other frameworks which focus on only one area, the Spring framework provides a wide variety of features addressing modern business needs via its portfolio of projects.

Spring framework provides the flexibility to configure beans in multiple ways, such as XML, Annotations, and JavaConfig. As the number of features increased, the complexity also increased, and configuring Spring applications became tedious and error-prone.

One of my blog followers sent an email asking me to show an example of “Real-World Usage of Spring AOP”. He mentioned that in most examples, the usage of Spring AOP is demonstrated for logging method entry/exit, Transaction management, or Security checks. He wanted to know how Spring AOP is being used in “Real Projects for Real Problems”.

So I would like to show how I have used Spring AOP in one of my projects to handle a real problem.

I am Siva, working as a Software Developer in Hyderabad, India. Working as a Software Developer is very exciting as you see new things coming in every day. If there are no new things, at least we put a new fancy name to some old concept and celebrate (#microservices) :-). But in my opinion, working as a Software Developer in India is a little bit different and hard too. A few things are good, and a few things are bad.

In the Java community, Spring vs. JavaEE is a never-ending debate. In such debates, people form two groups consisting of evangelists, architects, and hardcore fans of one platform and debate endlessly. Those who participate in the debates may be architects who are responsible for platform selection. But what would developers think about this Spring vs. JavaEE debate?

I am a Java developer who uses both Spring and JavaEE, and I am not part of the Spring or JavaEE fan club. Here, I would like to share my own thoughts on this epic Spring vs. JavaEE debate.

IT is one field where you can find new things coming every day. These days, the whole developer community websites are flooded with MicroServices and Docker-related stuff. Among them, the idea of MicroServices is very exciting and encourages a better way of building software systems. But as with any architectural style, there will be pros and cons to every approach.

Before discussing the good and bad sides of the MicroServices approach, first, let me say what I understood about MicroServices.

We spend more time reading code than writing it. So if the code is more readable, it will obviously increase developer productivity.

Many people associate the readability of code with coding conventions like following standard naming conventions, closing files, DB resources, etc. When it comes to code reviews, most people focus on these trivial things only, like checking for naming convention violations or whether resources are properly released in a finally block.

I am glad to announce that my second book, “PrimeFaces Beginner’s Guide,” has been published.

As many of us know, PrimeFaces is the leading JSF component library for JSF-based web applications. This “PrimeFaces Beginner’s Guide” book targets Java developers with a basic knowledge of JSF and jQuery and covers most of the commonly used PrimeFaces components.

The good news is that the “PrimeFaces Beginner’s Guide” book covers the latest PrimeFaces 4.0 version features, such as the Client-Side Validations (CSV) framework, Dialog Framework, Search Expressions, Sticky Component, and many other enhancements as well.

Hurray… My first book, Java Persistence with MyBatis3, is published. I would like to thank Packt Publishers for giving me this opportunity to write about my favorite framework, MyBatis.

For most software applications, data persistence is a key and important aspect. In the Java world, we have many ways of implementing the persistence layer, starting from low-level JDBC to fancy ORM frameworks. JDBC is too low-level an API and requires writing a lot of boilerplate code. On the other hand, we have full-fledged ORM frameworks like JPA (Hibernate, EclipseLink, etc.) which hide the complexity of working with SQL directly by letting developers work with objects and generate SQL based on the RDBMS (Dialect) being used. But each approach has its own set of pros and cons; there is no one-size-fits-all solution. Many large applications are using Hibernate successfully, and many other applications got screwed up by using Hibernate/JPA incorrectly. It is not a problem with JPA/Hibernate; it is simply because JPA/Hibernate may not be the best fit for those applications, or developers don’t understand them properly.