ALU

spring boot

Top 5 Spring Boot Features Java Developers Should Know

You might have heard about Spring Boot and it’s magical powers that can create a Spring Web application in just under 140 characters, but what does that really mean? What are these features that provide Spring Boot with so much power and can make Spring application development so easy? Well, that’s what you will learn in this article. We are going to talk about Spring Boot’s auto-configuration, starter dependencies, Spring Boot CLI, and Actuator and Spring Initializer features in greater detail. These are the features that take away most of the pain and friction associated with writing Spring-based Java web applications.

But before going into the details, let’s revisit problems associated with Spring-based Java development. I personally like to see the problem first and get a feel for it before I can enjoy the solution. Remember: comfort only feels better after hard work. It is the same for meals; you enjoy more when you are hungry.

Original Link

Kotlin: How to Implement a REST API With Spring Boot, Spring Data, and H2 DB

In this article, we are going to talk about Kotlin. I have developed a very simple REST API in Kotlin using Spring Boot, Spring Data, and the H2 in-memory DB.

Kotlin and Spring Boot work well together.

Original Link

Deploying Spring Boot and MongoDB as Containers Using Kubernetes and Docker

For this tutorial, you’ll have a Dockerized sample spring-boot application that talks to MongoDB for GET/POST REST APIs and deployed in Kubernetes cluster.

Prerequisites

  • minikube
  • kubectl
  • docker
  • maven

Docker is a Linux container management toolkit with a “social” aspect, allowing users to publish container images and consume those published by others. A Docker image is a recipe for running a containerized process, and in this guide, we will build one for a simple Spring boot application.

Original Link

Deploying Spring Boot and MongoDB as Containers Using Kubernetes and Docker

For this tutorial, you’ll have a Dockerized sample spring-boot application that talks to MongoDB for GET/POST REST APIs and deployed in Kubernetes cluster.

Prerequisites

  • minikube
  • kubectl
  • docker
  • maven

Docker is a Linux container management toolkit with a “social” aspect, allowing users to publish container images and consume those published by others. A Docker image is a recipe for running a containerized process, and in this guide, we will build one for a simple Spring boot application.

Original Link

Multiple Databases With Shared Entity Classes in Spring Boot and Java

Hello, everyone, It has been a few months since my last post. I have been busy traveling and relocating. In this post, I want to illustrate how a Spring Boot application can have multiple data sources with shared entity classes. The need for this arose in my current project where an in-memory database was needed for the high performance and a persistent database for storage.

In this blog post, I will use H2 for the in-memory database and Postgres for the persistent storage. I will setup up the application and show how the entities can be passed from one data source to another.

Original Link

This Week in Spring: Interviews, Releases, and Spring Tutorials

Hi, Spring fans! Welcome to another installment of This Week in Spring. I’m in Tokyo, Japan, for the epic SpringOne Tour Japan event, and then, it’s off to Seoul, South Korea, and then Singapore. I’m trying to keep busy! I delivered two 3+ hour long talks yesterday, despite a blistering fever, and today, I presented at the SpringOne Tour. Tonight, I had the honor of presenting at a joint meeting of the JJUG and JSUG here in Tokyo on Tuesday evening (starting about 7 hours ago).

If you’re out and about in Tokyo, don’t hesitate to say hi! I’d love to chat with ya about anything and everything Pivotal and Spring! Anyway, we’ve got a ton to get to, so let’s get started!

Original Link

Fully Working Prototypes With Spring Boot and H2

We use a lot of H2 with Spring, especially for unit tests. However, instead of unit tests, we might want to have a fully functional prototype with data to display.

H2 is the perfect candidate for that. It works great with Spring, has strong syntax compatibility with most databases out there, and provides a UI to check your data.

Original Link

Spring Batch: a Typical Use Case

In this article, I would like to show you a typical example of using Spring Batch. I assume that the reader has a basic knowledge about Spring Boot, Spring Batch, MongoDB, and Java 8.

Let’s get started.

Original Link

Using the Spring Boot Rest Service

I have used many frameworks in the past, even Spring. Yesterday, I was trying to help out one of the new joiners, and while trying to showcase the power of Spring Boot, I wrote this blog.

What I am using:

Original Link

K8s KnowHow – Running Your First Pod

In K8S, a pod is the smallest deployment unit. It’s the collection of one or more containers (preferably one container). All the containers packed in the pod share the same storage, network, and specifications of how to run the container. Let me make it simpler: running a pod represents a process and that’s it. 

For Java world developers, let me give you the other perspective of a pod. In simple terms, a pod is nothing but an execution environment consisting of JVM running the base container and other services to work with the K8S ecosystem. A pod is just a wrapper on the top of JVM. In the pre-container world, imagine you have virtual hosts on the physical node and different JVMs running on those virtual hosts. Now with K8S, a pod provides similar kind of isolation and abstraction in a quite elegant way with lightweight containers.

Original Link

Measuring Method Execution Times With Spring AOP and AspectJ in Spring Boot

Hey, all! Today, I will be talking about how to measure average method execution times using AspectJ with a Spring Boot application. We will declare a quartz job and log the average method executions.

First, we will define our pom.xml, like the following:

Original Link

This Week in Spring: Spring Boot, Releases, and Cloud

Hi, Spring fans! Welcome to another installment of This Week in Spring! This week, I’m in Paris, France, for the amazing Voxxed Microservices event. This has been quite the show, and I’m grateful for having had the opportunity to attend. Now, as I write this, I’m preparing to go to Beijing, China, for the first leg in Asia of the SpringOne Tour show. I’ll be in China, then Japan, Korea, Singapore, Hong Kong, Taiwan, Los Angeles, Morocco, Seattle, Toronto, and then finally, in mid-December, I’ll return home to San Francisco. We’ve got a ton of things to look at this week, so without further ado, let’s get to it!

Original Link

This Week in Spring: Oracle CodeOne Edition

Hi, Spring fans! Welcome to another installment of This Week in Spring! This week, I’ve just flown back from Canada and Russia where I was at the amazing Joker conference in St. Petersburg. I’m now in San Francisco (where I live!) for a couple of days to soak up the amazing atmosphere around Oracle CodeOne and be reunited with the Java community and longtime friends. I’m so excited about the presentation that fellow Java Champion Trisha Gee and I are doing tomorrow at 11:30 am that introduces an end-to-end reactive and Spring-based application from JavaFX client to service. Do not miss this!

After CodeOne, I’ll fly back to Europe for business in Connecticut, and then, it’s off to Paris, FR, for the Voxxed Days Microservices event.

Original Link

Simple Apache NiFi Operations Dashboard (Part 2): Spring Boot

If you missed Part 1, you can check it out here.

Simple Apache NiFi Operations Dashboard – Part 2

To access data to display in our dashboard we will use some Spring Boot 2.06 Java 8 microservices to call Apache Hive 3.1.0 tables in HDP 3.0 on Hadoop 3.1.

Original Link

Counting Distinct Users in Real-Time With Redis Using Low Memory

If you are developing an event-based application that handles many requests from different users, you most likely want to count distinct user action within a sliding window or a specified time range.

One of the quickest ways to count distinct user is to prepare an SQL like SELECT count(distinct user) from ACTION_TABLE. But, this might be expensive if there are millions of records produced in real time.

Original Link

A Closer Look at Spring Boot

Introduction

With the advent of microservices architecture and cloud computing, there is an increasing need for a new approach to artifact deployment: a standalone Java application.

In very little time, Spring Boot has become a leading technology in this fields.

Original Link

Azure SQL with PCF Spring Boot Applications (Part 2)

This is part 2 of the series demonstrating advanced Azure SQL (PAAS) features and how to use them from Java Spring Boot applications running on PCF (Pivotal CloudFoundry) on Azure. The first article showed how to use a Spring Boot application with Azure SQL Database auto-failover groups to provide resilience to regional outages and walked thru Azure Service Broker providing seamless integration with Azure services to applications running Pivotal CloudFoundry.

This article will demonstrate how to protect sensitive data (such as password, credit cards, and social security numbers) in Azure SQL database. Security and protection of the data becomes even more important to enterprises looking to migrate databases to the cloud. The Always Encrypted feature of Azure SQL enables customers to be confident that even high privileged but unauthorized users cannot access their encrypted data in the cloud. It safeguards data not only “at-rest” and ”in transit”, but also "in use” in any data lifecycle event and does it transparently to applications. Moreover, encryption keys are not stored within the database, they stay with the client (in the demo below — stored in Key Vault) and that’s why it keeps data protected even from cloud operators.

Original Link

Deploying Spring Boot to ECS (Part 2)

This post is a continuation from our previous post on deploying Spring Boot to ECS.  In our second installment, we will cover how to deploy a Spring Boot application in the ECS container. We will be using a simple task planner application that is available on GitHub.

A Docker file is already available inside this project. Make sure you have Git, Docker, and AWS CLI installed wherever you are running the following commands. Check out this link for a Git clone.

Original Link

Spring Boot and Swagger: Documenting RESTful Services

This guide will help you use Swagger with Spring Boot to document your RESTful services. We will learn how to expose automated Swagger documentation from your application. We will also add documentation to the REST API with swagger annotations.

You Will Learn

  • What is the need for documenting your RESTful services?
  • How do you document RESTful web services?
  • Why Swagger?
  • How can you use Swagger UI?
  • How do you automate the generation of Swagger Documentation from RESTful Web Services?
  • How do you add custom information to Swagger Documentation generated from RESTful Web Services?
  • What is Swagger UI?

10 Reference Courses

Project Code Structure

The following screenshot shows the structure of the project we will create. Image

Original Link

This Week in Spring: SpringOne Tour, Releases, and SpringOne Platform Wrap-Up

Hi, Spring fans! This week, I’m in sunny San Francisco for the epic SpringOne Tour San Francisco event. I’m head down and preparing for a large amount of travel ahead of me. Starting on the 14th, I’ll start four weeks of travel, bringing the message far-and-wide to Toronto, St. Petersburg, Brussels, San Francisco, Hartford, Paris, Beijing, Tokyo, Singapore, Seoul, Hong Kong, and… I forget… but, there’s more! I’m so looking forward to seeing you all at each and every one of those places!

I also loved this tweet from Pivotal:

Original Link

Advanced Functional Testing in Spring Boot Using Docker in Tests

Overview

This article focuses on applying some of the best practices during the functional testing of a Spring Boot application. We will demonstrate an advanced approach on how to test a service as a black box without setting up the staging environment. This article is the continuation of my previous post, Native Integration Testing in Spring Boot, so I will refer to it to show the difference between these two types of testing. I recommend taking a look at that before reading this post.

Theory

Let’s start with defining what functional testing means:

Original Link

5 Ways to Run Spring Boot Apps

In this article, we will discuss different ways of running Spring Boot applications:

1. Running from an IDE
2. Running as a Packaged Application
3. Using the Maven Plugin
4. Using External Tomcat
5. Using the Gradle Plugin

Original Link

Introducing Servlet 4.0 Server Push Using Spring Boot 2.1

In this article, we will be talking about Server Push Technology that is actually part of the HTTP/2 spec.

The most important feature of Servlet 4.0, due to HTTP/2, is the implementation of the server push capability. The concept behind this technique is that if the client/browser requests a certain resource, the server assumes, in advance, that some other related resources may also be requested soon. Because of this assumption, it pushes them into the cache (called ‘cache push’) before they are actually needed. For example, it is very much likely that when a webpage is loaded, it may eventually request a CSS file or another image. The server proactively starts pushing the bytes of these assets simultaneously, without the need for the client to make an explicit request.

Original Link

Multiple MongoDB Connectors With Spring Boot

This tutorial will guide you in the process to connect to multiple MongoDBs.

What You Will Build

You will build an application that connects to multiple MongoDBs.

Original Link

Using the Spring Boot @SpringBootApplication Annotation

In this article, we will discuss the importance of the annotation @SpringBootApplication with an example to get you started. Let’s get into it!

@SpringBootApplication Annotation Overview

@SpringBootApplication annotation indicates a configuration class that declares one or more @Bean methods and also triggers auto-configuration and component scanning. This is a convenient annotation, which is the equivalent of declaring @Configuration, @EnableAutoConfiguration, and @ComponentScan.
Let’s look at an internal implementation of the @SpringBootApplication annotation by looking into its source code. The diagram below shows an internal implementation of @SpringBootApplication: SpringBootApplication Annotation

Original Link

REST API Error Handling With Spring Boot

Introduction

Spring Boot provides a great exception handling mechanism out of the box. The default implementation ofErrorController does a good job of catching and handling exceptions. Also, we still can define our own @ExceptionHandler s to catch and handle specific exceptions. But, there is still room for improvement:

  • Even if we decide to handle all exceptions using a custom @ExceptionHandler, some exceptions will still manage to escape that handler and theErrorController would be responsible for exception handling. This@ExceptionHandler vs. ErrorController duality can definitely be improved.
  • Sometimes, the default error representation looks a bit messy:
{ "timestamp": "2018-09-23T15:05:32.681+0000", "status": 400, "error": "Bad Request", "errors": [ { "codes": [ "NotBlank.dto.name", "NotBlank.name", "NotBlank.java.lang.String", "NotBlank" ], "arguments": [ { "codes": [ "dto.name", "name" ], "arguments": null, "defaultMessage": "name", "code": "name" } ], "defaultMessage": "{name.not_blank}", "objectName": "dto", "field": "name", "rejectedValue": null, "bindingFailure": false, "code": "NotBlank" } ], "message": "Validation failed for object='dto'. Error count: 1", "path": "/"
}

Original Link

Creating Dual Layer Docker Images for Spring Boot Apps

In the first part of this series on Optimizing Spring Boot Apps for Docker, we looked at the single layer approach to building Docker images for Spring Boot applications and the implications it has for CI/CD pipelines. I proposed that a dual layer approach has concrete benefits over the single layer approach and that these benefits are in the form of efficiencies in iterative development environments.

Here, we introduce an approach to creating dual layer Docker images for existing Spring Boot applications using a new tool in Open Liberty called springBootUtility. There are alternate approaches to creating multi-layered Docker images for Spring Boot applications[1], but this approach focuses on creating a dual layer image from the existing application rather than altering a Maven or Gradle build step.

Original Link

Optimizing Spring Boot Apps for Docker

Docker is powerful and simple to use. It allows developers to create portable, self-contained images for the software they create. These images can be reliably and repeatably deployed. You can easily retrieve the value from Docker, but to get the most out of Docker, there are some concepts that are important for you to understand. How you build your Docker image has a measurable impact when you are doing continuous integration and delivery. In this article, I will focus on how to take a more efficient approach to build Docker images for Spring Boot applications when doing iterative development and deployment. The standard approach has some drawbacks, so here, we look at what they are and how to do it better.

Key Docker Concepts

There are four key Docker concepts at play: images, layers, the Dockerfile, and the Docker cache. Simply put, the Dockerfile describes how to build the Docker image. An image consists of a number of layers. The Dockerfile starts with a base image and adds additional layers. A new layer is generated when new content is added to the image. Each layer that is built is cached so it can be re-used on subsequent builds. When a Docker build runs, it will re-use any existing layers that it can from the cache. This reduces the overall time and space needed for each build. Anything that has changed, or has not been built before, will be built as needed.

Original Link

Building CI/CD Pipelines for Java Using Azure DevOps (Formerly VSTS)

Last week, Microsoft announced their CI/CD solution name change from Visual Studio Team Services to Azure DevOps. Let’s face it, most Java developers cringe and run when they see the term “Visual Studio” with the misconception that the tool will be for .NET users only.  I have to confess; I was one of those guilty Java developers until I discovered that it is actually a powerful solution for any language or platform to utilize during project release cycles.

The Azure DevOps service offers several features for such as adding team members, Kanban boards, Repo options, Build/Release Pipelines, Test Plans, Build Artifacts (e.g. Maven) and much more. It also integrates with your favorite tools like Eclipse, IntelliJ, Jenkins or Chef.  For microservices, Java developers will be happy to know that it supports container build services like Docker, Kubernetes, Cloud Foundry etc.

Original Link

Spring Boot Listener for AWS SQS With Spring Cloud

Spring Cloud AWS makes it easy to create a Java method that listens for messages on an Amazon SQS queue.  Between Spring Boot and Spring Cloud, I was surprised by just how little code I needed to make all this happen.

The key is that when you have the right dependencies in your Maven POM, all you have to do is annotate your listener method with  @SqsListener:

Original Link

An Alternative Approach to ThreadLocal Using Spring

In a blog post published some time ago, Multitenant Applications Using Spring Boot JPA Hibernate and Postgres, I included code set to and to retrieve from the tenant identifier, a discriminator for selecting its associated data source using a ThreadLocal reference:

  • A context holder class for holding the tenant data:
...
public class DvdRentalTenantContext { private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>(); public static void setTenantId(String tenantId) { CONTEXT.set(tenantId); } public static String getTenantId() { return CONTEXT.get(); } public static void clear() { CONTEXT.remove(); }
}

Original Link

This Week in Spring: SpringOne Platform, Spring Cloud, and New Releases

Hi, Spring fans! Welcome to another installment of This Week in Spring! It’s the week before SpringOne Platform and things are crazy! We have so much to cover  —as usual — but first, it’s time for some poetry (with apologies to Clement Clark Moore):

’twas the week before SpringOne Platform, when all throughout Spring;
Not a creature was stirring, just the computers and things;
the expectations were raised by the community with care;
in hopes that SpringRod would soon be there;

Original Link

How to Run Any Dockerized Application on Spring Cloud Data Flow

Spring Cloud Data Flow (SCDF) provides tools to build streaming and batch data pipelines. The data processing pipelines could be deployed on top of a container orchestration engine, for example,  Kubernetes. Spring Boot applications could be one of the starter apps or custom boot applications packaged as Docker images if Kubernetes is the runtime for these pipelines. However, Python is a popular data munging tool, but SCDF cannot natively interpret Python Docker images. In this article, we will create a streaming data pipeline that starts a Python Docker image in one of the intermediate steps and use the result of computation in downstream components.

Scenario

Let us consider a scenario where we are receiving data from sensors that generate sensor data tags as time series data. The sensor data is a JSON array, an example of which is shown below.

Original Link

Deployment Setup for Spring Boot Apps With MongoDB and Kubernetes

In this article, we demonstrate the setup of an AngularAndSpring project to show the development setup with an in-memory MongoDB and Kubernetes setup for deployment. The goal for the development setup is to have a Spring Boot app that can be run without a local MongoDB installation and be developed with fast restarts. The goal for the Deployment Setup is to build a Docker image of the project and to run it in a Kubernetes setup with a MongoDB image to have horizontal scalability of the front-end.

Development Setup

To get the in-memory MongoDB, this profile has to be added to the pom.xml:

Original Link

Simplifying Packaging Spring Boot 2 Applications Into Docker Images Using Google’s Jib

1. Introduction

Ever since I published Microservices using Spring Boot, Jersey, Swagger and Docker, I had entertained the idea of making Package the service into a Docker image section its own blog post.

Back then I used Spotify’s docker-maven-plugin, which required connecting to a Docker host. Also felt it would have been almost identical to the section mentioned.

Original Link

Test-Driven Development With a Spring Boot REST API

I deal with integration tests for RESTful applications a lot, however, I had not particularly tried Test Driven Development (TDD) methodologies. Therefore, I decided to give it a try, and I say now tell that I quite like it. I shall assume you already have some basic ideas of TDD, therefore I shall forgo an introduction to TDD.

In this article, let us look at how we can adopt TDD methodology in implementing a Spring Boot RESTful application.

Original Link

Bootiful GCP: Use Spring Cloud GCP to Connect to Other GCP Services

Hi, Spring fans! In this brief part of the series, we’re going to look at the Spring Cloud integration for Google Cloud Platform, Spring Cloud GCP. Spring Cloud GCP represents a joint effort between Google and Pivotal that endeavors to provide a first-class experience for Spring Cloud developers when using the Google Cloud Platform. Pivotal Cloud Foundry users will enjoy an even easier integration with the GCP service broker. I wrote these installments with input from Google Cloud Developer Advocate, and my buddy, Ray Tsang. You can also catch a walkthrough of Spring Cloud GCP in our Google Next 2018 session, Bootiful Google Cloud Platform. Thanks, buddy! As always, I’d love to hear from you if you have feedback. Let’s get into it.

The Spring Cloud GCP project strives to provide integrations with Spring and some of the GCP services that map well to Spring. But, GCP is vast! There is a good deal of other services out there that you can consume via their direct Java SDK or even through their REST APIs directly. Spring Cloud GCP can make working with those APIs a bit easier, too! In this section, we’re going to integrate the Google Cloud Vision API, which supports analyzing images and doing feature detection.

Original Link

This Week in Spring: SpringOne, Google Cloud, and Apache Geode

Hi, Spring fans, and welcome to another installment of This Week in Spring! If you’re in the US, I hope you enjoyed your Labor Day weekend. I certainly did, gorging on the San Francisco sun and preparing for my O’Reilly online training for tomorrow, Bootiful Kotlin. I’m also busily preparing for the epic SpringOne Tour event in Istanbul, Turkey, customer visits in Atlanta, GA, and, of course, the epic tentpole SpringOne Platform event coming up later this month in Washington DC. If you’re around, I sure hope to see you!

Well, let’s get to it!

Original Link

Using Docker to Shove an Existing Application Into Some Containers

I have finally got round to learning how to use Docker past the level of knowing what it is and does without ever using it. This is the first post that I have attempted to use Docker in and will probably be what I refer to whenever I start a new project (for Java or Kotlin anyway).

This will be a short post that takes an existing project (from one of my other posts) and alters it so it can run inside of containers. I doubt this post will contain anything impressive but I know it will help me in the future and maybe it will help you now.

Original Link

Spring Sweets: Dockerize Spring Boot Application With Jib

Jib is an open-source Java library from Google designed for creating Docker images for Java applications. Jib can be used as a Maven or Gradle plugin in our Spring Boot projects. One of the nice features of Jib is that it adds layers to our classes, resources, and dependency libraries for the Docker image. This means that when only class files have changed, the classes layer is rebuilt, but the others remain the same. Therefore, the creation of a Docker image with our Spring Boot application is also very fast (after the first creation). Also, the Maven and Gradle plugins have sensible defaults, like using the project name and version as image name, so we don’t have to configure anything in our build tool. Although, Jib provides options to configure other values for the defaults, for example, to change the JVM options passed on to the application.

Let’s see Jib in action in this sample Spring Boot application. We will use Gradle as a build tool with the following Spring Boot application:

Original Link

Spring Boot: Messaging With RabbitMQ Pub/Sub in PCF

In my previous article, I demonstrated how to create a simple RabbitMQ message producer and consumer. In this article, I would like to demonstrate how to create a simple RabbitMQ pub/sub messaging model using the Spring Boot starter packs and what it takes to deploy the application in PCF. 

In the example below, I will create a simple message producer that will send a message to an exchange, which, in turn, will route the message to the appropriate queue based on the routing key. Once the message is sent to the appropriate queue, we will consume the same and print it in the console. For the sake of simplicity, I’m using the direct exchange. If you want to experiment with other types of exchanges, like Topic, Default or Fanout, you will have to create and inject the beans accordingly.

Original Link

Setting Up MDC Context With AOP in Spring Boot Applications

In order to be able to analyze logs of complex processes for your application, it is useful to use Mapped Diagnostic Context (MDC) and put some process specific information into it. Currently, I am implementing a Spring Boot application with several services and lots of calls between them. As there is a huge number of users parallel, when it comes to analyzing a production log, it is not easy to find the subsequent process calls, belonging to a REST call in the log file.

In order to make my life easier, there is still a unique session ID in the log, using MDC, to find all the calls belonging to a specific user and call. But, to make the analysis easier, I decided to add function-specific information to the logs. So, if a REST method gets called, it can set the logical function name in the MDC. Therefore, all later calls to the helper or DAO classes can be logged with the same function name and can be found easily.

Original Link

This Week in Spring: SpringOne Platform, Spring Cloud, and JDK 11 Candidate

Hi, Spring fans! Welcome to another installment of This Week in Spring! This week I am in Chicago for the SpringOne Tour Chicago event. If you’re around, then, of course, don’t hesitate to say hi! Mostly, though, I’ve been busily preparing for the epic SpringOnePlatform event being held in historic Washington D.C. in September. I hope to see you there!

We’ve got a lot to get through, so let’s get to it!

Original Link

Spring Boot — Messaging With RabbitMQ in PCF

In this article, I would like to demonstrate how to create a simple RabbitMQ message producer and consumer using the Spring Boot starter packs and what it takes to deploy the application in PCF. 

In the example below, I will create a simple message producer that will drop a simple JSON string into a queue in the PCF RabbitMQ message broker and then create a simple message consumer that will consume the same message and print the details in the console.  

Original Link

My Favorite Features of Spring Boot

Spring Boot is a lightweight framework that takes most of the work out of configuring Spring-based applications. It follows the “Opinionated Defaults Configuration” approach to reduce developer effort.

In this article, I will talk about some of my favorite features:

Original Link

Manage User Session With Spring JDBC Session

This article will demonstrate how to configure and use the Spring Session to manage session data in a web application with Spring Boot. For a more in-depth look at the code, check out this GitHub repository.

Introduction

In a web application, user session management is crucial for managing user state. Spring Session is an implementation of four approaches, storing session data in a persistent data store. Spring Session supports multiple datastores, like RDBMS, Redis, HazelCast, MongoDB, etc., to save the user session data.

Original Link

Generate a DOCX Report From Your Trello Board

I have been using the Trello board over the last few months for project management. During this period, I needed to generate reports via Word or DOCX, and among the constraints, I found that there are cards written in different languages.

In this article, I will provide a detailed Java program that can generate a DOCX report of a Trello board and translate content into a single output language, basing it on Google Translation and Cloud API Translation.

Original Link

A Start to Finish Guide to Docker With Java, Part 1

Intro to Managing and Running a Containerized Java Spring Boot Application

Docker is a platform for packaging, deploying, and running applications in containers. It can run containers on any system that supports the platform: a developer’s laptop, systems on "on-prem," or in the cloud without modification. Images, the packages Docker uses for applications, are truly cross-platform.

Java microservices are a good target for Docker. Running a service in a container augments development with a common target platform for development, testing, and deployment. Containers are also an excellent first step toward moving to a flexible and cost-effective cloud architecture.

Original Link

  • 1
  • 2
  • 4