Sravan Cynixit

How To Work with Arrays in Ruby

2020-05-06T10:09:53.556Z

Introduction

An array is a data structure that represents a list of values, called elements. Arrays let you store multiple values in a single variable. This can condense and organize your code, making it more readable and maintainable. And because arrays are objects with their own methods, they can make working with lists of data much easier.

If you want to Gain In-depth Knowledge on Ruby On Rails, please go through this link Ruby On Rails Online Training

In Ruby. arrays can contain any datatype, including numbers, strings, and other Ruby objects.

Let’s look at a simple example of how powerful arrays can be. Imagine you had to maintain a list of email addresses. Without an array, you might store email addresses in variables, like this:

emails.rb

email1 = "ceo@example.com"
email2 = "admin@example.com"
email3 = "support@example.com"
email4 = "sales@example.com"

This approach is verbose and can quickly become difficult to maintain, as it’s not very flexible. Adding another email address means you’d have to add, and track, an additional variable.

If you use an array, you can simplify this data:

emails.js

emails = [
  "ceo@example.com",
  "admin@example.com",
  "support@example.com",
  "sales@example.com"
]

Instead of creating five separate variables, you now have one variable that contains all four email addresses. In this example, we used square brackets — [] — to create an array, and separated each entry with a comma. If you had to add an additional email address, you would add another email address to the array rather than creating and managing a new variable.

To access a specific item, or element of an array, you reference its index, or its position in the array. In Ruby, indexes start at zero. so to retrieve the first element from our emails array, we append the element’s index to the variable using square brackets, like this:

print emails[0];

Outputceo@example.com

In this tutorial, you’ll create arrays, access the values they contain, add, modify, and remove elements in an array, and iterate through the elements in an array to solve more complex problems. Let’s start by looking at how to create arrays in more detail.

Creating an Array

To create an array in a Ruby program, use square brackets: ([]), and separate the values you want to store with commas.

For example, create an array of sharks and assign it to a variable, like this:

sharks.rb

sharks = ["Hammerhead", "Great White", "Tiger"]

You can print out an entire array with the print statement, which will display the array’s contents:

print sharks

Output["Hammerhead", "Great White", "Tiger"]

If you want to create an array where each entry is a single word, you can use the %w{} syntax, which creates a word array:

days = %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday}

This is equivalent to creating the array with square braces:

days =  ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

However, notice that the %w{} method lets you skip the quotes and the commas.

Arrays are often used to group together lists of similar data types, but in Ruby, arrays can contain any value or a mix of values, including other arrays. Here’s an example of an array that contains a string, a nil value, an integer, and an array of strings:

mixed_data.rb

record = [
    "Sammy",
    null,
    7,
    [
        "another",
        "array",
    ]
]

Now let’s look at how we access data stored in arrays.

Accessing Items in Arrays

You access an item in a Ruby array by referring to the index of the item in square brackets.

Let’s explore this concept with our array of sharks, assigned to the variable sharks:

sharks.rb

sharks = ["Hammerhead", "Great White", "Tiger"]

The sharks array has three elements. Here is a breakdown of how each element in the sharks array is indexed.

Hammerhead

Greate White

Tiger

The first element in the array is Hammerhead, which is indexed at 0. The last element is Tiger, which is indexed at 2. Counting starts with 0 in indices, which goes against our natural intuition to start counting at 1, so you’ll want to keep this in mind until it becomes natural.

Note: It might help you to think of the index as an offset; it’s the number of places from the start of the array. The first element is at the beginning, so its offset, or index, is 0. The second element is one spot away from the first entry in the array, so its offset, or index, is 1.

You can find out how many elements are in an array with the length method.

sharks.length

Output3

Although the indices of sharks start at 0 and go to 2, the length property returns the number of elements in the array, which is 3. It’s not concerned with the indices at all.

If you wanted to find out the index number of a specific element in an array, such as seahorse, use the index() method:

print sharks.index("Tiger")

Output2

This returns the index of the first element containing that text. If an index number is not found, such as for a value that does not exist, the console will return nil.

print sharks.index("Whale")

Outputnil

To get the last element of an array in Ruby, use the index -1:

print sharks[-1]

Output"Tiger"

Ruby also provides the first and last methods to get the first and last elements without using indices:

puts sharks.first
puts sharks.last

Output"Hammerhead"
"Tiger"

Attempting to access an index that doesn’t exist will return nil.

sharks[10]

Outputnil

Arrays can contain other arrays, which we call nested arrays. This is one way to model two-dimentional data sets in a program. Here’s an example of a nested array:

nested_array = [
    [
        "salmon",
        "halibut",
    ],
    [
        "coral",
        "reef",
    ]
]

In order to access elements in a nested array, you would add another index number to correspond to the inner array. For example, to retrive the value coral from this nested array, you’d use the following statement:

print nested_array[1][0];

Outputcoral

In this example, we accessed the array at position 1 of the nested_array variable, which returned the array ["coral", "reef"]. We then accessed the elements at position 0 of that array, which was "coral".

Take your career to new heights of success with an Ruby On Rails Online Course

Now let’s look at how to add elements to an array.

Adding Elements

We have three elements in our sharks array, which are indexed from 0 to 2:

sharks.rb

sharks = ["Hammerhead", "Great White", "Tiger"]

There are a few ways to add a new element. You could assign a value to the next index, which in this case would be 3:

sharks[3] = "whale";

print sharks

Output["Hammerhead", "Great White", "Tiger", "Whale"]

This method is error-prone though. If you add an element and accidentally skip an index, it will create a nil element in the array.

sharks[5] = "Sand";

print sharks;

Output["Hammerhead", "Great White", "Tiger", "Whale", nil, "Sand"]

Attempting to access the extra array element will return its value, which will be nil.

sharks[4]

Outputnil

Finding the next available index in an array is error-prone and takes extra time. Avoid errors by using the push method, which adds an element to the end of an array:

sharks.push("thresher")
print sharks

Output["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher"]

You can also use the << syntax instead of the push method to add an element to the end of an array:

sharks << "Bullhead"

Output["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

To add an element to the beginning of an array, use the unshift() method:

sharks.unshift("Angel")
print sharks

Output["Angel", "Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Now that you know how to add elements, let’s look at removing them.

Removing Elements

To remove a specific element from an array, use the delete or delete_at methods. In the sharks array, we accidentally created a nil array element earlier. Let’s get rid of it.

First, find its position in the array. You can use the index method to do that:

print sharks.index(nil)

Output4

Then use delete_at to remove the element at index 4 and print the array:

sharks.delete_at(4)
print sharks

Output["Angel", "Hammerhead", "Great White", "Tiger", "Whale", "Thresher", "Bullhead"]

The delete method removes elements from an array that match the value you pass in. Use it to remove Whale from the array:

sharks.delete("Whale")
print sharks;

Output["Angel", "Hammerhead", "Great White", "Tiger", "Thresher", "Bullhead"]

The delete method will remove all occurances of the value you pass, so if your array has duplicate elements, they’ll all be removed.

The pop method will remove the last element in an array.

sharks.pop
print sharks;

Output["Angel", "Hammerhead", "Great White", "Tiger", "Thresher"]

Bullhead has been removed as the last element of the array. In order to remove the first element of the array, use the shift method.

sharks.shift
print sharks

Output["Hammerhead", "Great White", "Tiger", "Thresher"]

This time, Angel was removed from the beginning of the array.

By using pop and shift, you can remove elements from the beginning and the end of arrays. Using pop is preferred wherever possible, as the rest of the items in the array retain their original index numbers.

The delete_at, pop, and shift methods all change the original array and return the element you deleted. Try this example:

sharks.rb

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
deleted_at_element = sharks.delete_at(1)
popped_element = sharks.pop

puts "Deleted_at element: #{deleted_at_element}"
puts "Popped element: #{popped_element}"

puts "Remaining array: #{sharks}"

OuptutDeleted_at element: Great White
Popped element: Whale
Remaining array: ["Hammerhead", "Tiger"]

You now know several ways to remove elements from an array. Now let’s look at how to modify the element we already have.

Modifying Existing Elements

To update an element in the array, assign a new value to the element’s index by using the assignment operator, just like you would with a regular variable.

Given a new array of sharks, with "Hammerhead" at index 0, let’s replace "Hammerhead" with "Angel":

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks[0] = "Angel"
print sharks;

Output["Angel", "Great White", "Tiger", "Whale"]

To make sure you update the right element, you could use the index method to locate the element first, just like you did to find the element you wanted to delete.

Now let’s look at how to work with all of the elements in the array.

Iterating Over an Array

Ruby provides many ways to iterate over an array, and each method you use depends on the kind of work you want to perform. In this article, we’ll explore how to iterate over an array and display each of its elements.

Ruby provides the for..in syntax, which looks like this:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
for shark in sharks do
  puts shark
end

Here’s how it works. For each element in the sharks array, Ruby assigns that element to the local variable shark. We can then print the element’s value using puts.

You won’t see for..in very often though. Ruby arrays are objects, and they provide the each method for working with elements. The each method works in a similar fashion to for..in, but has a different syntax:

each.rb

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each do |shark|
  puts shark
end

The each method uses a syntax you’ll see often in Ruby programming. It takes a Ruby block as its argument. A block is some code that will be executed later in the context of the method. In this case, the code is puts shark. The shark keyword, enclosed in the pipe characters (|), is the local variable that represents the element in the array that the block will access. Ruby assigns the element to this variable and executes the code in the block. The each method repeats this process for each element in the array. The result looks like this:

OutputHammerhead
Great White
Tiger
Whale

When the block is only a single line, you often see Ruby developers replace the do and end keywords with curly braces and condense the whole statement into a single line, like this:

each.rb

...
sharks.each {|shark| puts shark }

This produces the same results but uses fewer lines of code.

The each_with_index method works in a similar manner, but it also gives you access to the index of the array element. This program uses each_with_index to print out the index and the value for each element:

each_with_index.rb

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each_with_index do |shark, index|
  puts "The index is #{index}"
  puts "The value is #{shark}"
end

For each element in the array, Ruby assigns the element to the variable shark, and assigns the current index to the index variable. We can then reference both of those variables in the block.

The result of this program looks like this:

OutputThe index is 0
The value is Hammerhead
The index is 1
The value is Great White
The index is 2
The value is Tiger
The index is 3
The value is Whale

You’ll interate over the elements in an array often in your own programs, such as when you need to display the items from a database on a website, or when you’re reading lines from a file and processing their contents.

Conclusion

Arrays are an extremely versatile and fundamental part of programming in Ruby. In this tutorial, you created arrays and accessed individual elements. You also added, removed, and modified elements in an array. Finally, you explored two ways to iterate over an array and display its contents, which is used as a common method to display data.

Spring Boot And Spring MVC Detailed Comparision As Of 2020 It Eliminates All Your Doubts

2020-05-02T09:32:13.158Z

Introduction

Spring is an application framework highly popular for the development of enterprise applications. It is built for Java and allows software developers to implement the enterprise systems of various sizes including POS, e-commerce, ERP, banking, and so on. The Spring Framework offers a comprehensive configuration and programming model for the latest enterprise applications based on Java on any type of deployment platform.

Spring 5 is the latest version of Spring framework and it has the support for reactive web applications. Being reactive implies that a system is elastic, message-driven, responsive, and resilient. Spring Framework’s two of the most important features are inversion of control (IOC) and dependency injection (DI). This is because, we can build loosely coupled applications when DI and IOC are used properly. More Latest Information At Spring Boot Online Training

What is Spring MVC?

One of the modules of the Web layer of the Spring Framework is the Web-Servlet module. This module consists of Spring Framework’s MVC (model-view-controller) implementation for web applications. It provides a model-view-controller architecture and ready elements that can be utilized to build loosely coupled and flexible web applications.

The model-view-controller pattern results in dissociating the various aspects of application such as UI logic, business logic, input logic while offering a loose coupling between these components. Spring MVC is designed around a DispatcherServlet that deals with the HTTP requests and responses.

What is Spring Boot?

Spring Boot is a way to ease the creation of stand-alone application with zero or minimal configurations. It is basically an approach to build applications based on Spring framework with minimal configuration. Spring Boot makes it easy for the creation of production-grade, spring powered services and applications with minimum confusion.

It can be used for traditional WAR deployments or for the creation of stand-alone Java applications. Spring Boot provides a widely accessible and a radically faster ‘getting started’ experience for the entire Spring development.

Wish to Learn Spring Boot? Learn it from industry experts.! on Spring Boot Certification

Comparing Spring Boot and Spring MVC

In the above paragraphs, we have learnt what is Spring Framework, Spring Boot, and Spring MVC. Now, let’s compare Spring MVC and Spring Boot. One of the most common dilemmas for the newbie developers who want to use Spring Framework is which one they should go for, either for Spring MVC or Spring Boot.

Well, if you are a new developer, you may think you should go for Spring Boot as it is the latest one. So, let’s dig deeper into the comparison part and understand which one is more recommended than the other.

Wish to Learn Spring Boot? Learn it from industry experts.! on Spring Boot Certification

Spring MVC

Spring MVC is a HTTP oriented web application development framework and is a module of Spring framework.
It provides a decoupled way of building web applications. It will let you implement your web application in accordance with the model-view-controller design pattern.
Spring MVC is equivalent to JSF(Java Server Faces) in the JavaEE stack. Classes annotated with @Controller are the most popular elements in Spring MVC.
For the implementation of REST-based APIs, Spring MVC has an equivalent @RestController.

Spring Boot

Spring Boot enables you to rapidly build and create Spring applications utilizing the Spring framework.
You need more configuration on your part if you choose to avoid Spring Boot.
The features that only Spring Boot can offer are the capability to create standalone web applications and auto-configuration.
You can do things such as incorporate H2 on the build path with the help of auto-configuration. For an in-memory database, Spring will auto-configure the connection details without any further configuration.
The starter projects provided by Spring Boot will increase productivity by providing defaults and configurations to minimize the effort of a developer avoiding writing a lot of XML configuration, annotations, and boilerplate code.
Spring Boot also offers embedded http servers such as Jetty, Tomcat, etc. which you can package together with your applications for creating executable war files.
With the help of Spring Boot, you can tell Spring how many of its modules(spring-web, spring-date, spring-core, and so on) to use and you will also get a quick setup for them.

You can use Spring MVC if you want to develop a web application with Spring. However, for the development of general Spring applications or beginning to learn Spring, it is recommended that you use Spring Boot as it is production ready, mitigates the job, and is being quickly adopted. Also, Spring Boot can use Spring MVC and autoconfigure it. In this case, the choice won’t be between MVC and Boot but between Boot or Bootless. This depends on how open to associated risks and innovation your organization is.

Today, most of the Spring projects are integrated completely with Boot and even the Spring community began to develop various applications based on Spring Boot(monitoring and managing for example). You can benefit from very nice and useful features like remote shell and actuator for monitoring and managing with Boot. This enhances your application with production-ready features.

Spring Boot has very powerful and nice configuration controls. Because of these, you can extend the Boot in a very simple and impressive way. Boot is one of the first microservice ready platforms.

Your project configuration will be very simple with the help of Boot and you need not maintain an XML file as well. Boot provides a lot of default implementation and JPA integration and Spring Hibernate will be pretty simple.

Conclusion

So, if you look at the comparison part, Spring Boot is more useful when compared with Spring MVC as it has many inbuilt features and benefits which make it more reliable to use than MVC. Most of the things are auto configured using Boot. Just like Tomcat, Boot bundles a war file with server runtime. This enables for easy deployment and distribution of web applications. To get in-depth knowledge, enroll for a live free demo on Spring Boot Training

Spring Boot is quite useful for container based deployments as industry is moving towards them. Though Spring MVC is the oldest and widely used JVM web framework and it has a large community of followers which are quite helpful and have provided numerous answers and tutorials, the popularity of Spring Boot is growing at a rapid pace and the reasons are mentioned clearly in the above section.

Introduction to Spring Framework

2020-05-01T06:40:48.156Z

Introduction:

Prior to the advent of Enterprise Java Beans (EJB), Java developers needed to use Java Beans to create Web applications. Although JavaBeans helped in the development of user interface (UI) components, they were not able to provide services, such as transaction management and security, which were required for developing robust and secure enterprise applications. The advent of EJB was seen as a solution to this problem EJB extends the Java components, such as Web and enterprise components, and provides services that help in enterprise application development. However, developing an enterprise application with EJB was not easy, as the developer needed to perform various tasks, such as creating Home and Remote interfaces and implementing lifecycle callback methods which lead to the complexity of providing code for EJBs Due to this complication, developers started looking for an easier way to develop enterprise applications.

If you want to Gain In-depth Knowledge on Spring Boot, please go through this link Spring Boot Online Training

The Spring framework has emerged as a solution to all these complications This framework uses various new techniques such as Aspect-Oriented Programming (AOP), Plain Old Java Object (POJO), and dependency injection (DI), to develop enterprise applications, thereby removing the complexities involved while developing enterprise applications using EJB, Spring is an open-source lightweight framework that allows Java EE 7 developers to build simple, reliable, and scalable enterprise applications. This framework mainly focuses on providing various ways to help you manage your business objects. It made the development of Web applications much easier as compared to classic Java frameworks and Application Programming Interfaces (APIs), such as Java database connectivity(JDBC), JavaServer Pages(JSP), and Java Servlet.

The Spring framework can be considered as a collection of sub-frameworks, also called layers, such as Spring AOP. Spring Object-Relational Mapping (Spring ORM). Spring Web Flow, and Spring Web MVC. You can use any of these modules separately while constructing a Web application. The modules may also be grouped together to provide better functionalities in a Web application.

Features of te Spring Framework:

The features of the Spring framework such as IoC, AOP, and transaction management, make it unique among the list of frameworks. Some of the most important features of the Spring framework are as follows:

IoC container:- Refers to the core container that uses the DI or IoC pattern to implicitly provide an object reference in a class during runtime. This pattern acts as an alternative to the service locator pattern. The IoC container contains assembler code that handles the configuration management of application objects.
The Spring framework provides two packages, namely org.springframework.beans and org.springframework.context which helps in providing the functionality of the IoC container.
Data access framework:- Allows the developers to use persistence APIs, such as JDBC and Hibernate, for storing persistence data in the database. It helps in solving various problems of the developer, such as how to interact with a database connection, how to make sure that the connection is closed, how to deal with exceptions, and how to implement transaction management It also enables the developers to easily write code to access the persistence data throughout the application. For more Additional info at Spring Boot Online Course
Spring MVC framework:- Allows you to build Web applications based on MVC architecture. All the requests made by a user first go through the controller and are then dispatched to different views, that is, to different JSP pages or Servlets. The form handling and form validating features of the Spring MVC framework can be easily integrated with all popular view technologies such as ISP, Jasper Report, FreeMarker, and Velocity.
Transaction management:- Helps in handling transaction management of an application without affecting its code. This framework provides Java Transaction API (JTA) for global transactions managed by an application server and local transactions managed by using the JDBC Hibernate, Java Data Objects (JDO), or other data access APIs. It enables the developer to model a wide range of transactions on the basis of Spring’s declarative and programmatic transaction management.
Spring Web Service:- Generates Web service endpoints and definitions based on Java classes, but it is difficult to manage them in an application. To solve this problem, Spring Web Service provides layered-based approaches that are separately managed by Extensible Markup Language (XML) parsing (the technique of reading and manipulating XML). Spring provides effective mapping for transmitting incoming XML message request to an object and the developer to easily distribute XML message (object) between two machines.
JDBC abstraction layer:- Helps the users in handling errors in an easy and efficient manner. The JDBC programming code can be reduced when this abstraction layer is implemented in a Web application. This layer handles exceptions such as DriverNotFound. All SQLExceptions are translated into the DataAccessException class. Spring’s data access exception is not JDBC specific and hence Data Access Objects (DAO) are not bound to JDBC only.
Spring TestContext Framework:- Provides facilities of the unit and integration testing for the Spring applications. Moreover, the Spring TestContext framework provides specific integration testing functionalities such as context management and caching DI of test fixtures, and transactional test management with default rollback semantics.

What Is Spring Boot? — Sravan Cynixit’s projectSpring Boot is an open-source micro framework maintained by a company called Pivotal. It provides Java developers with…scrapbox.io

Evolution of Spring Framework

The Spring Framework was first released in 2004. After that there has been a significant major revision, such as Spring 2.0 provided XML namespaces and AspectJ support, Spring 2.5 provide annotation-driven configuration, Spring 3.0 provided a Java-based @Configuration model. The latest release of the spring framework is 4.0. it is released with the support for Java 8 and Java EE 7 technologies. Though you can still use Spring with an older version of java, the minimum requirement is restricted to Java SE 6. Spring 4.0 also supports Java EE 7 technologies, such as java message service (JMS) 2.0, java Persistence API (JPA) 2.1, Bean validation 1.1, servlet 3.1, and JCache.

Spring Framework Architecture

The Spring Framework consists of seven modules which are shown in the above Figure. These modules are Spring Core, Spring AOP, Spring Web MVC, Spring DAO, Spring ORM, Spring context, and Spring Web Flow. These modules provide different platforms to develop different enterprise applications; for example, you can use the Spring Web MVC module for developing MVC-based applications.

Spring Framework Modules

Spring Core Module:- The Spring Core module, which is the core component of the Spring framework, provides the IoC container There are two types of implementations of the Spring container, namely, bean factory and application context. Bean factory is defined using the org.springframework.beans.factory.BeanFactory interface and acts as a container for beans. The Bean factory container allows you to decouple the configuration and specification of dependencies from program logic. In the Spring framework, the Bean factory acts as a central IoC container that is responsible for instantiating application objects. It also configures and assembles the dependencies between these objects. There are numerous implementations of the BeanFactory interface. The XmlBeanFactory class is the most common implementation of the BeanFactory interface. This allows you to express the object to compose your application and remove interdependencies between application objects.
Spring AOP Module:- Similar to Object-Oriented Programming (OOP), which breaks down the applications into hierarchy of objects, AOP breaks down the programs into aspects or concerns. Spring AOP module allows you to implement concerns or aspects in a Spring application in Spring AOP, the aspects are the regular Spring beans or regular classes annotated with @Aspect annotation. These aspects help in transaction management and logging and failure monitoring of an application. For example, transaction management is required in bank operations such as transferring an amount from one account to another Spring AOP module provides a transaction management abstraction layer that can be applied to transaction APIs.
Spring ORM Module:- The Spring ORM module is used for accessing data from databases in an application. It provides APIs for manipulating databases with JDO, Hibernate, and iBatis. Spring ORM supports DAO, which provides a convenient way to build the following DAOs-based ORM solutions:
• Simple declarative transaction management
• Transparent exception handling
• Thread-safe, lightweight template classes
• DAO support classes
• Resource management
Spring Web MVC Module:- The Web MVC module of Spring implements the MVC architecture for creating Web applications. It separates the code of model and view components of a Web application. In Spring MVC, when a request is generated from the browser, it first goes to the DispatcherServlet class (Front Controller), which dispatches the request to a controller (SimpleFormController class or AbstractWizardformController class) using a set of handler mappings. The controller extracts and processes the information embedded in a request and sends the result to the DispatcherServlet class in the form of the model object. Finally, the DispatcherServlet class uses ViewResolver classes to send the results to a view, which displays these results to the users.
Spring Web Flow Module:- The Spring Web Flow module is an extension of the Spring Web MVC module. Spring Web MVC framework provides form controllers, such as class SimpleFormController and AbstractWizardFormController class, to implement predefined workflow. The Spring Web Flow helps in defining XML file or Java Class that manages the workflow between different pages of a Web application. The Spring Web Flow is distributed separately and can be downloaded through http://www.springframework.org website.
The following are the advantages of Spring Web Flow:
• The flow between different UIs of the application is clearly provided by defining Web flow in XML file.
• Web flow definitions help you to virtually split an application in different modules and reuse these modules in multiple situations.
•Spring Web Flow lifecycle can be managed automatically

To get in-depth knowledge on Spring Boot, Enroll for live free demo on Spring Boot Training

Spring Web DAO Module:- The DAO package in the Spring framework provides DAO support by using data access technologies such as JDBC, Hibernate, or JDO. This module introduces a JDBC abstraction layer by eliminating the need for providing tedious JDBC coding. It also provides programmatic as well as declarative transaction management classes. Spring DAO package supports heterogeneous Java Database Connectivity and O/R mapping, which helps Spring work with several data access technologies. For easy and quick access to database resources, the Spring framework provides abstract DAO base classes. Multiple implementations are available for each data access technology supported by the Spring framework. For example, in JDBC, the JdbcDaoSupport class and its methods are used to access the DataSource instance and a preconfigured JdbcTemplate instance. You need to simply extend the JdbcDaoSupport class and provide a mapping to the actual DataSource instance in an application context configuration to access a DAO-based application.
Spring Application Context Module:- The Spring Application context module is based on the Core module. Application context org.springframework.context.ApplicationContext is an interface of BeanFactory. This module derives its feature from the org.springframework.beans package and also supports functionalities such as internationalization (I18N), validation, event propagation, and resource loading. The Application context implements Message Source interface and provides the messaging functionality to an application.

Spring Boot Security + JWT Hello World Example

2020-04-30T07:43:50.723Z

In this tutorial, we will be developing a Spring Boot application that makes use of JWT authentication for securing an exposed REST API. In this example, we will be making use of hard-coded user values for user authentication. In the next tutorial, we will be implementing Spring Boot + JWT + MYSQL JPA for storing and fetching user credentials. Any user will be able to consume this API only if it has a valid JSON Web Token (JWT). In a previous tutorial, we learned what is JWT and when and how to use it.

If you want to Gain In-depth Knowledge on Spring Boot, please go through this link Spring Boot Training

For better understanding, we will be developing the project in stages:

Develop a Spring Boot application that exposes a simple REST GET API with mapping /hello.

Configure Spring Security for JWT. Expose REST POST API with mapping/authenticate using which User will get a valid JSON Web Token. And then, allow the user access to the API /hello only if it has a valid token

Develop a Spring Boot Application That Exposes a GET REST API

The Maven project will look as follows:

The pom.xml is as follows:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">	<modelVersion>4.0.0</modelVersion>	<groupId>com.javainuse</groupId>	<artifactId>spring-boot-jwt</artifactId>	<version>0.0.1-SNAPSHOT</version>	<parent>		<groupId>org.springframework.boot</groupId>		<artifactId>spring-boot-starter-parent</artifactId>		<version>2.1.1.RELEASE</version>		<relativePath /> <!-- lookup parent from repository -->	</parent>	<properties>		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>		<java.version>1.8</java.version>	</properties>	<dependencies>		<dependency>			<groupId>org.springframework.boot</groupId>			<artifactId>spring-boot-starter-web</artifactId>		</dependency>	</dependencies></project>

package com.javainuse.controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class HelloWorldController {	@RequestMapping({ "/hello" })	public String firstPage() {		return "Hello World";	}}

Create the bootstrap class with Spring Boot Annotation

package com.javainuse;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class SpringBootHelloWorldApplication {	public static void main(String[] args) {		SpringApplication.run(SpringBootHelloWorldApplication.class, args);	}}

Compile and the run the SpringBootHelloWorldApplication.java as a Java application.
Go to localhost:8080/hello

Spring Security and JWT Configuration

We will be configuring Spring Security and JWT for performing 2 operations-

Generating JWT — Expose a POST API with mapping /authenticate. On passing correct username and password it will generate a JSON Web Token(JWT)
Validating JWT — If user tries to access GET API with mapping /hello. It will allow access only if request has a valid JSON Web Token(JWT) at Spring Boot Online Training

Maven Project will be as follows-

The sequence flow for these operations will be as follows-

Generating JWT

Add the Spring Security and JWT dependencies

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">	<modelVersion>4.0.0</modelVersion>	<groupId>com.javainuse</groupId>	<artifactId>spring-boot-jwt</artifactId>	<version>0.0.1-SNAPSHOT</version>	<parent>		<groupId>org.springframework.boot</groupId>		<artifactId>spring-boot-starter-parent</artifactId>		<version>2.1.1.RELEASE</version>		<relativePath /> <!-- lookup parent from repository -->	</parent>	<properties>		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>		<java.version>1.8</java.version>	</properties>	<dependencies>		<dependency>			<groupId>org.springframework.boot</groupId>			<artifactId>spring-boot-starter-web</artifactId>		</dependency>		<dependency>			<groupId>org.springframework.boot</groupId>			<artifactId>spring-boot-starter-security</artifactId>		</dependency>		<dependency>			<groupId>io.jsonwebtoken</groupId>			<artifactId>jjwt</artifactId>			<version>0.9.1</version>		</dependency>	</dependencies></project>

Define the application.properties. As see in previous JWT tutorial, we specify the secret key using which we will be using for hashing algorithm. The secret key is combined with the header and the payload to create a unique hash. We are only able to verify this hash if you have the secret key.

jwt.secret=javainuse

JwtTokenUtil

The JwtTokenUtil is responsible for performing JWT operations like creation and validation.It makes use of the io.jsonwebtoken.Jwts for achieving this.

package com.javainuse.config;import java.io.Serializable;import java.util.Date;import java.util.HashMap;import java.util.Map;import java.util.function.Function;import org.springframework.beans.factory.annotation.Value;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.stereotype.Component;import io.jsonwebtoken.Claims;import io.jsonwebtoken.Jwts;import io.jsonwebtoken.SignatureAlgorithm;@Componentpublic class JwtTokenUtil implements Serializable {	private static final long serialVersionUID = -2550185165626007488L;	public static final long JWT_TOKEN_VALIDITY = 5 * 60 * 60;	@Value("${jwt.secret}")	private String secret;	//retrieve username from jwt token	public String getUsernameFromToken(String token) {		return getClaimFromToken(token, Claims::getSubject);	}	//retrieve expiration date from jwt token	public Date getExpirationDateFromToken(String token) {		return getClaimFromToken(token, Claims::getExpiration);	}	public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {		final Claims claims = getAllClaimsFromToken(token);		return claimsResolver.apply(claims);	}    //for retrieveing any information from token we will need the secret key	private Claims getAllClaimsFromToken(String token) {		return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();	}	//check if the token has expired	private Boolean isTokenExpired(String token) {		final Date expiration = getExpirationDateFromToken(token);		return expiration.before(new Date());	}	//generate token for user	public String generateToken(UserDetails userDetails) {		Map<String, Object> claims = new HashMap<>();		return doGenerateToken(claims, userDetails.getUsername());	}	//while creating the token -	//1. Define  claims of the token, like Issuer, Expiration, Subject, and the ID	//2. Sign the JWT using the HS512 algorithm and secret key.	//3. According to JWS Compact Serialization(https://tools.ietf.org/html/draft-ietf-jose-json-web-signature-41#section-3.1)	//   compaction of the JWT to a URL-safe string 	private String doGenerateToken(Map<String, Object> claims, String subject) {		return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))				.setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1000))				.signWith(SignatureAlgorithm.HS512, secret).compact();	}	//validate token	public Boolean validateToken(String token, UserDetails userDetails) {		final String username = getUsernameFromToken(token);		return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));	}}

JWTUserDetailsService

JWTUserDetailsService implements the Spring Security UserDetailsService interface. It overrides the loadUserByUsername for fetching user details from the database using the username. The Spring Security Authentication Manager calls this method for getting the user details from the database when authenticating the user details provided by the user. Here we are getting the user details from a hardcoded User List. In the next tutorial we will be adding the DAO implementation for fetching User Details from the Database. Also the password for a user is stored in encrypted format using BCrypt. Previously we have seenSpring Boot Security — Password Encoding Using Bcrypt. Here using the Online Bcrypt Generator you can generate the Bcrypt for a password.

package com.javainuse.service;import java.util.ArrayList;import org.springframework.security.core.userdetails.User;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;@Servicepublic class JwtUserDetailsService implements UserDetailsService {	@Override	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {		if ("javainuse".equals(username)) {			return new User("javainuse", "$2a$10$slYQmyNdGzTn7ZLBXBChFOC9f6kFjAqPhccnP6DxlWXx2lPk1C3G6",					new ArrayList<>());		} else {			throw new UsernameNotFoundException("User not found with username: " + username);		}	}}

JwtAuthenticationController

Expose a POST API /authenticate using the JwtAuthenticationController. The POST API gets username and password in the body- Using Spring Authentication Manager we authenticate the username and password.If the credentials are valid, a JWT token is created using the JWTTokenUtil and provided to the client.

package com.javainuse.controller;import java.util.Objects;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.ResponseEntity;import org.springframework.security.authentication.AuthenticationManager;import org.springframework.security.authentication.BadCredentialsException;import org.springframework.security.authentication.DisabledException;import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.web.bind.annotation.CrossOrigin;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RestController;import com.javainuse.service.JwtUserDetailsService;import com.javainuse.config.JwtTokenUtil;import com.javainuse.model.JwtRequest;import com.javainuse.model.JwtResponse;@RestController@CrossOriginpublic class JwtAuthenticationController {	@Autowired	private AuthenticationManager authenticationManager;	@Autowired	private JwtTokenUtil jwtTokenUtil;	@Autowired	private JwtUserDetailsService userDetailsService;	@RequestMapping(value = "/authenticate", method = RequestMethod.POST)	public ResponseEntity<?> createAuthenticationToken(@RequestBody JwtRequest authenticationRequest) throws Exception {		authenticate(authenticationRequest.getUsername(), authenticationRequest.getPassword());		final UserDetails userDetails = userDetailsService				.loadUserByUsername(authenticationRequest.getUsername());		final String token = jwtTokenUtil.generateToken(userDetails);		return ResponseEntity.ok(new JwtResponse(token));	}	private void authenticate(String username, String password) throws Exception {		try {			authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));		} catch (DisabledException e) {			throw new Exception("USER_DISABLED", e);		} catch (BadCredentialsException e) {			throw new Exception("INVALID_CREDENTIALS", e);		}	}}

JwtRequest

This class is required for storing the username and password we recieve from the client.

package com.javainuse.model;import java.io.Serializable;public class JwtRequest implements Serializable {	private static final long serialVersionUID = 5926468583005150707L;		private String username;	private String password;		//need default constructor for JSON Parsing	public JwtRequest()	{			}	public JwtRequest(String username, String password) {		this.setUsername(username);		this.setPassword(password);	}	public String getUsername() {		return this.username;	}	public void setUsername(String username) {		this.username = username;	}	public String getPassword() {		return this.password;	}	public void setPassword(String password) {		this.password = password;	}}

JwtResponse

This is class is required for creating a response containing the JWT to be returned to the user.

package com.javainuse.model;import java.io.Serializable;public class JwtResponse implements Serializable {	private static final long serialVersionUID = -8091879091924046844L;	private final String jwttoken;	public JwtResponse(String jwttoken) {		this.jwttoken = jwttoken;	}	public String getToken() {		return this.jwttoken;	}}

JwtRequestFilter

The JwtRequestFilter extends the Spring Web Filter OncePerRequestFilter class. For any incoming request this Filter class gets executed. It checks if the request has a valid JWT token. If it has a valid JWT Token then it sets the Authentication in the context, to specify that the current user is authenticated.

package com.javainuse.config;import java.io.IOException;import javax.servlet.FilterChain;import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;import org.springframework.security.core.context.SecurityContextHolder;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;import org.springframework.stereotype.Component;import org.springframework.web.filter.OncePerRequestFilter;import com.javainuse.service.JwtUserDetailsService;import io.jsonwebtoken.ExpiredJwtException;@Componentpublic class JwtRequestFilter extends OncePerRequestFilter {	@Autowired	private JwtUserDetailsService jwtUserDetailsService;	@Autowired	private JwtTokenUtil jwtTokenUtil;	@Override	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)			throws ServletException, IOException {		final String requestTokenHeader = request.getHeader("Authorization");		String username = null;		String jwtToken = null;		// JWT Token is in the form "Bearer token". Remove Bearer word and get		// only the Token		if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {			jwtToken = requestTokenHeader.substring(7);			try {				username = jwtTokenUtil.getUsernameFromToken(jwtToken);			} catch (IllegalArgumentException e) {				System.out.println("Unable to get JWT Token");			} catch (ExpiredJwtException e) {				System.out.println("JWT Token has expired");			}		} else {			logger.warn("JWT Token does not begin with Bearer String");		}		// Once we get the token validate it.		if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {			UserDetails userDetails = this.jwtUserDetailsService.loadUserByUsername(username);			// if token is valid configure Spring Security to manually set			// authentication			if (jwtTokenUtil.validateToken(jwtToken, userDetails)) {				UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(						userDetails, null, userDetails.getAuthorities());				usernamePasswordAuthenticationToken						.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));				// After setting the Authentication in the context, we specify				// that the current user is authenticated. So it passes the				// Spring Security Configurations successfully.				SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);			}		}		chain.doFilter(request, response);	}}

JwtAuthenticationEntryPoint

This class will extend Spring’s AuthenticationEntryPoint class and override its method commence. It rejects every unauthenticated request and send error code 401

package com.javainuse.config;import java.io.IOException;import java.io.Serializable;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.security.core.AuthenticationException;import org.springframework.security.web.AuthenticationEntryPoint;import org.springframework.stereotype.Component;@Componentpublic class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable {	private static final long serialVersionUID = -7858869558953243875L;	@Override	public void commence(HttpServletRequest request, HttpServletResponse response,			AuthenticationException authException) throws IOException {		response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");	}}

WebSecurityConfig

This class extends the WebSecurityConfigurerAdapter is a convenience class that allows customization to both WebSecurity and HttpSecurity.

Take your career to new heights of success with an Spring Boot Online Course

package com.javainuse.config;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.security.authentication.AuthenticationManager;import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;import org.springframework.security.config.annotation.web.builders.HttpSecurity;import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;import org.springframework.security.config.http.SessionCreationPolicy;import org.springframework.security.core.userdetails.UserDetailsService;import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;import org.springframework.security.crypto.password.PasswordEncoder;import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;@Configuration@EnableWebSecurity@EnableGlobalMethodSecurity(prePostEnabled = true)public class WebSecurityConfig extends WebSecurityConfigurerAdapter {	@Autowired	private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;	@Autowired	private UserDetailsService jwtUserDetailsService;	@Autowired	private JwtRequestFilter jwtRequestFilter;	@Autowired	public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {		// configure AuthenticationManager so that it knows from where to load		// user for matching credentials		// Use BCryptPasswordEncoder		auth.userDetailsService(jwtUserDetailsService).passwordEncoder(passwordEncoder());	}	@Bean	public PasswordEncoder passwordEncoder() {		return new BCryptPasswordEncoder();	}	@Bean	@Override	public AuthenticationManager authenticationManagerBean() throws Exception {		return super.authenticationManagerBean();	}	@Override	protected void configure(HttpSecurity httpSecurity) throws Exception {		// We don't need CSRF for this example		httpSecurity.csrf().disable()				// dont authenticate this particular request				.authorizeRequests().antMatchers("/authenticate").permitAll().				// all other requests need to be authenticated				anyRequest().authenticated().and().				// make sure we use stateless session; session won't be used to				// store user's state.				exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and().sessionManagement()				.sessionCreationPolicy(SessionCreationPolicy.STATELESS);		// Add a filter to validate the tokens with every request		httpSecurity.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);	}}

Start the Spring Boot Application

Generate a JSON Web Token -
Create a POST request with url localhost:8080/authenticate. Body should have valid username and password. In our case username is javainuse and password is password.

Validate the JSON Web Token
- Try accessing the url localhost:8080/hello using the above generated token in the header as follows

Prepare for your next Spring Boot interview with these common interview questions.

In this article, we will discuss some top 10 interview questions in Spring Boot. These questions are a bit tricky and trending heavily, nowadays, in the job market.

1) What does the Spring Boot Application annotation do internally?

As per the Spring Boot doc, the Spring Boot Application annotation is equivalent to using Configuration, Enable Auto Configuration, and Component Scan with their default attributes. Spring Boot enables the developer to use a single annotation instead of using multiple. But, as we know, Spring provided loosely coupled features that we can use for each individual annotation as per our project needs Spring Boot Online Training.

2) How to exclude any package without using the basePackages filter?

There are different ways you can filter any package. But Spring Boot provides a trickier option for achieving this without touching the component scan. You can use the exclude attribute while using the annotation @SpringBootApplication. See the following code snippet:

@SpringBootApplication(exclude= {Employee.class})public class FooAppConfiguration {}

3) How to disable a specific auto-configuration class?

You can use the exclude attribute of@EnableAutoConfiguration, if you find any specific auto-configuration classes that you do not want are being applied.

//By using "exclude"@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})

On the other foot, if the class is not on the classpath, you can use the excludeName attribute of the annotation and specify the fully qualified name instead.

//By using "excludeName"@EnableAutoConfiguration(excludeName={Foo.class})

Also, Spring Boot provides the facility to control the list of auto-configuration classes to exclude by using the spring.autoconfigure.exclude property. You can add into the application.properties. And you can add multiple classes with comma separated.

//By using property filespring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

4) What is Spring Actuator? What are its advantages?

This is one of the most common interview questions in Spring Boot. As per the Spring doc:

As we know, Spring Boot provides lots of auto-configuration features that help developers quickly develop production components. But if you think about debugging and how to debug, if something goes wrong, we always need to analyze the logs and dig through the data flow of our application to check to see what’s going on. So, the Spring Actuator provides easy access to those kinds of features. It provides many features, i.e. what beans are created, the mapping in the controller, the CPU usage, etc. Automatically gathering and auditing health and metrics can then be applied to your application.

It provides a very easy way to access the few production-ready REST endpoints and fetch all kinds of information from the web. But by using these endpoints, you can do many things to see here the endpoint docs. There is no need to worry about security; if Spring Security is present, then these endpoints are secured by default using Spring Security’s content-negotiation strategy. Or else, we can configure custom security by the help of RequestMatcher.

5) How to enable/disable the Actuator?

Enabling/disabling the actuator is easy; the simplest way is to enable features to add the dependency (Maven/Gradle) to the spring-boot-starter-actuator, i.e. Starter. If you don’t want the actuator to be enabled, then don’t add the dependency.

Maven dependency:

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency></dependencies>

6) What is the Spring Initializer?

This may not be a difficult question, but the interviewer always checks the subject knowledge of the candidate. It’s often that you can’t always expect questions that you have prepared. However, this is a very common question asked almost all of the time.

The Spring Initializer is a web application that generates a Spring Boot project with everything you need to start it quickly. As always, we need a good skeleton of the project; it helps you to create a project structure/skeleton properly.

7) What is a shutdown in the actuator?

Shutdown is an endpoint that allows the application to be gracefully shutdown. This feature is not enabled by default. You can enable this by using management.endpoint.shutdown.enabled=true in your application.properties file. But be careful about this if you are using this.

8) Is this possible to change the port of Embedded Tomcat server in Spring boot?

Yes, it’s possible to change the port. You can use the application.properties file to change the port. But you need to mention “server.port” (i.e. server.port=8081). Make sure you have application.properties in your project classpath; REST Spring framework will take care of the rest. If you mention server.port=0 , then it will automatically assign any available port. You can learn more about the Embedded Tomcat Server here Spring Boot Online Course.

9) Can we override or replace the Embedded Tomcat server in Spring Boot?

Yes, we can replace the Embedded Tomcat with any other servers by using the Starter dependencies. You can use spring-boot-starter-jetty or spring-boot-starter-undertow as a dependency for each project as you need.

10) Can we disable the default web server in the Spring Boot application?

The major strong point in Spring is to provide flexibility to build your application loosely coupled. Spring provides features to disable the web server in a quick configuration. Yes, we can use the application.properties to configure the web application type, i.e. spring.main.web-application-type=none.

All the best!

Netflix OSS and Spring Boot — Coming Full Circle

2020-04-25T13:12:54.381Z

In 2007, Netflix started on a long road towards fully operating in the cloud. Much of Netflix’s backend and mid-tier applications are built using Java, and as part of this effort Netflix engineering built several cloud infrastructure libraries and systems — Ribbon for load balancing, Eureka for service discovery, and Hystrix for fault tolerance. To stitch all of these components together, additional libraries were created — Governator for dependency injection with lifecycle management and Archaius for configuration. All of these Netflix libraries and systems were open-sourced around 2012 and are still used by the community to this day.

If you want to Gain In-depth Knowledge on Java Spring Boot, please go through this link Spring Boot Online Training

In 2015, Spring Cloud Netflix reached 1.0. This was a community effort to stitch together the Netflix OSS components using Spring Boot instead of Netflix internal solutions. Over time this has become the preferred way for the community to adopt Netflix’s Open Source software. We are happy to announce that starting in 2018, Netflix is also making the transition to Spring Boot as our core Java framework, leveraging the community’s contributions via Spring Cloud Netflix.

Why is Netflix adopting Spring Boot after having invested so much in internal solutions? In the early 2010s, key requirements for Netflix cloud infrastructure were reliability, scalability, efficiency, and security. Lacking suitable alternatives, we created solutions in-house. Fast forward to 2018, the Spring product has evolved and expanded to meet all of these requirements, some through the usage and adaptation of Netflix’s very own software! In addition, community solutions have evolved beyond Netflix’s original needs. Spring provides great experiences for data access (spring-data), complex security management (spring-security), integration with cloud providers (spring-cloud-aws), and many many more.

The evolution of Spring and its features align very well with where we want to go as a company. Spring has shown that they are able to provide well-thought-out, documented, and long lasting abstractions and APIs. Together with the community they have also provided quality implementations from these abstractions and APIs. This abstract-and-implement methodology match well with a core Netflix principle of being “highly aligned, loosely coupled”. Leveraging Spring Boot will allow us to build for the enterprise while remaining agile for our business.

Let's Get more knowledge on spring Kubernetes go with How to utilize Spring Boot Microservices on Kubernetes

The Spring Boot transition is not something we are undertaking alone. We have been in collaboration with Pivotal throughout the process. Whether it be Github issues and feature requests, in-person conversations at conferences or real-time chats over Gitter/Slack, the responses from Pivotal have been excellent. This level of communication and support gives us great confidence in Pivotal’s ability to maintain and evolve the Spring ecosystem.

Moving forward, we plan to leverage the strong abstractions within Spring to further modularize and evolve the Netflix infrastructure. Where there is existing strong community direction — such as the upcoming Spring Cloud Load Balancer — we intend to leverage these to replace aging Netflix software. Where there is new innovation to bring — such as the new Netflix Adaptive Concurrency Limiters — we want to help contribute these back to the community.

The union of Netflix OSS and Spring Boot began outside of Netflix. We now embrace it inside of Netflix. This is just the beginning of a long journey, and we will be sure to provide updates and interesting findings as we go. We want to give special thanks to the many people who have contributed to this effort over the years and hope to be part of future innovations to come.

The autoload Method in Ruby

2020-04-24T11:40:47.809Z

In this article we’re going to explore the following topics:

autoload registration & lazy loading
the Module#autoload? method
the Module#autoload method behind the scene

If you want to Gain In-depth Knowledge on Ruby On Rails, please go through this link Ruby On Rails Online Training

`autoload` registration & lazy loading

The Module#autoload method registers a file path to be loaded the first time that a specified module or class is accessed in the namespace of the calling module or class.

Let’s detail a simple example to break down the previous assertion.

module Car
  autoload(:Engine, './engine.rb')

  puts "The Engine module isn't yet loaded!"
  Engine
  puts "The Engine module has been successfully loaded!"
end

module Engine
  puts 'The Engine module is loading!'
end

now let’s run our Ruby script

$> ruby car.rbThe Engine module isn’t yet loaded!The Engine module is loading!The Engine module has been successfully loaded!

Here we see that after a call to autoload(:Engine, ‘./engine.rb’) The engine.rb is not yet loaded.

In effect, this file is only loaded when we explicitly call the Engine module.

This mechanism allows Ruby to only load the files that contain the modules/classes used by the execution flow of the running program.

The `Module#autoload?` method

The Module#autoload? is in charge of checking if a registered module/class in a specific namespace has already been loaded or not.

It’s also used for checking if a module is registered (or not) as autoload in a specific namespace

module A
  autoload(:B, './b.rb')

  p autoload?(:B)
  B
  p autoload?(:B)
end

module B
  puts 'The module B is loading!'
end

produces

"./b.rb"The module B is loading!nil

The first call to autoload? :B returns the "./b.rb" file path.

Then the B module is loaded via a loading of the b.rb file.

Finally, the second call to autoload? :B returns nil because the B module is already loaded.

So, let’s autoload a C module outside of the the A namespace

autoload(:C, './c.rb')

module A
  p autoload? :C
end

p autoload? :C

module C
end

produces

nil"./c.rb"

The call to autoload? :C within the A namespace returns nil because the :C module is registered as autoload in the top-level namespace and not in the A namespace.

Take your career to new heights of success with an Ruby On Rails Training

In contrary, the second call to autoload? :C is invoked within the top-level namespace. As it’s within the same namespace as the autoload(:C, './c.rb') registration then it returns the "./c.rb" file path.

Now that we are more familiar with the autoload registration mechanism, let’s dive into what happens behind the scene when we register and call a module.

The `Module#autoload` method behind the scene

When the Module#autoload method is called within a specific namespace then the module/class and the file path given as arguments of the method are stored in an internal hash table.

Let’s have a look to this example

module A
  autoload(:B, './b.rb')
  
  p constants
end

module B
end

produces

[:B]

Here, we can see that the B constant exists even if it hasn’t been loaded yet.

In effect, a call to autoload will automatically create a constant named as the first argument of the method and flagged as autoload registered. The value of this constant will be undefined and NOT nil.

When the B module will be invoked then Ruby will search for the B entry within the constants hash table of the A namespace.

It’ll then load the file using the Kernel#require method

Finally the constant hash table will unflag as autoload the B module.

Deploying Spring Boot Applications

2020-04-23T11:42:18.041Z

Spring Boot applications can be deployed into production systems with various methods. In this article, we will go through step by step deployment of Spring Boot applications via the following 5 methods:

If you want to Gain In-depth Knowledge on Spring Boot, please go through this link Spring Boot Online Training

Deploying in Java Archive (JAR) as a standalone application,
Deploying as Web Application Archive (WAR) into a servlet container,
Deploying in Docker Container,
Deploying behind NGINX web server — direct setup,
Deploying behind NGINX web server — containerized setup.

Deploying in Java Archive (JAR) as a standalone application

Spring Boot applications can easily be packaged into JAR files and deployed as standalone applications. This is done by the spring-boot-maven-plugin. The plugin is automatically added to pom.xml once the Spring project is created via Spring Initializr as a Maven project.

<build>  <plugins>    <plugin>      <groupId>org.springframework.boot</groupId>      <artifactId>spring-boot-maven-plugin</artifactId>    </plugin>  </plugins></build>

In order to package the application in a single (fat) jar file, run the maven command mvn package under project directory. This will package the application inside an executable jar file with all its dependencies (including the embedded servlet container — if its a web application). To run the jar file, use the following standard JVM command java -jar <jar-file-name>.jar.

Deploying as Web Application Archive (WAR) into a servlet container

Spring Boot applications can be packaged into WAR files to be deployed into existing servlet containers (such as Tomcat, Jetty etc.). This can be done as follows:

Specify WAR packaging in pom.xml file via <packaging>war</packaging>. This will package the application into a WAR file (instead of JAR). On the second step, set the scope of Tomcat (servlet container) dependency to provided (so that it is not deployed into WAR file):

<dependency>  <groupId>org.springframework.boot</groupId>  <artifactId>spring-boot-starter-tomcat</artifactId  <scope>provided</scope></dependency>

Initialise the Servlet context required by Tomcat by extending SpringBootServletInitializer and overriding configure method as follows:

@SpringBootApplicationpublic class DemoApp extends SpringBootServletInitializer {  @Override  protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {    return builder.sources(DemoApp.class);  }  public static void main(String[] args) {    SpringApplication.run(DemoApp.class, args);  }}

In order to package the application in a war file, run the standard maven command mvn clean package under project directory. This will generate the WAR package which can be deployed into a servlet container. To run the application inside an existing Tomcat container, copy the generated WAR file to tomcat/webapps/ directory.

Deploying in Docker Container

Before deploying the application into a Docker container, we will first package the application in a (fat) JAR file. This process is previously explained, therefore I will assume we have a jar file.

On the first step, we need to build a container image. For this, we start with creating a Dockerfile in the project root directory as follows:

# latest oracle openjdk is the basisFROM openjdk:oracle# copy jar file into container image under app directoryCOPY target/demoApp.jar app/demoApp.jar# expose server port accept connectionsEXPOSE 8080# start applicationCMD ["java", "-jar", "app/demoApp.jar"]

Note that, in the above snippet, we assumed that the application JAR file ‘demoApp.jar’ is located under the target directory of our project. We also assumed that the embedded servlet port is 8080 (which is the default case for Tomcat).

Take your career to new heights of success with an Spring Boot Online Course

We can now build the Docker image with the following command (from where the Dockerfile is located):

docker image build -t demo-app:latest .

where -t is the name and tag of the image to be built. Once the image is built, we can create and run the container via:

docker container run -p 8080:8080 -d --name app-container demo-app

where -p publishes (maps) host port to container port (in this case both are 8080). The option -d (detach) runs the container in background, and --name specifies the name of the container.

Deploying behind NGINX web server — direct setup

Configuring servlet containers (such as Tomcat or Jetty) for real production (i.e. running on port 80, without root user and with SSL) may not be straight forward (but doable). Therefore, it is recommended to use a web server (such as Nginx) in front of your Spring Boot applications. This can be done in two ways; direct setup or containerized setup. In this section, we will demonstrate the direct setup.

In direct setup, we run the Nginx web server and the Spring Boot applications directly on localhost (on different ports of course). And we let Ngnix proxy REST requests to Spring Boot applications. For this:

Install Nginx web server on Linux via sudo apt-get install nginx,
Open the file /etc/ngnix/sites-available/default with a text editor,
Say, we have two Spring Boot applications to be proxied. Then replace the ‘location’ block in the file with following blocks for two Spring Boot applications. Note that, all Nginx-Java configs can be found here.

location /app1 {  proxy_pass http://localhost:8080;}location /app2 {  proxy_pass http://localhost:9000;}

based on which the requests coming to http://localhost/app1/ will be directed to /http://localhost:8080/, and requests coming to http://localhost/app2/ will be directed to /http://localhost:9000/.

Load balancing

If you are running multiple instances of a Spring Boot application, you can enable Nginx to apply load-balancing. For example, if we have 3 instances of app1 running on ports 8080, 8081 and 8082. We can load-balance among these servers as follows:

Open the file /etc/ngnix/sites-available/default and add the following block at the top of the file (before server block):

# configure load-balancingupstream backend {  server localhost:8080;  server localhost:8081;  server localhost:8082;}

Modify the proxy_pass parameter of app1 as follows:

location /app1 {  proxy_pass http://backend;}

based on which the requests coming to http://localhost/app1/ will be directed to one of/http://localhost:8080/, /http://localhost:8081/ or /http://localhost:8082/.

Deploying behind NGINX web server — containerized setup

In containerized setup, we deploy the Nginx web server and all the Spring Boot applications on separate Docker containers. And we let Nginx (running in its own container) proxy REST requests to Spring Boot application containers.

We start by packaging all Spring Boot applications in (fat) jar files (which is previously explained). At this point, pay attention to setting individual server ports and root context paths to each Spring Boot application by adding following lines to application.properties (or application.yml) files:

server.port=8082server.servlet.context-path=/search-service

Then we deploy the generated jar packages in separate Docker containers (which is also previously explained).

As an example, we deploy four Spring Boot applications; single instance of ‘analysis-service’ application and three instances of ‘search-service’ application. The three instances of search-service application will be load-balanced by Nginx. Our basic architecture looks like follows:

We create a Nginx configuration file nginx.conf based on the default configurations. We add load-balancing and proxy information for each service as follows:

http {  upstream backend {    server search-service-1:8080;    server search-service-2:8081;    server search-service-3:8082;  }  server {    listen 80 default_server;    listen [::]:80 default_server;    root /var/www/html;    server_name _;    location /search-service {      proxy_pass http://backend/search-service;    }    location /analysis-service {      proxy_pass http://analysis-service:8083/analysis-service;    }  }}events { worker_connections 1024; }

based on which the requests coming to http://localhost/search-service/ will be directed to one of/http://search-service-1:8080/search-service/, /http://search-service-2:8081/search-service/ and /http://search-service-3:8082/search-service/, and requests coming to http://localhost/analysis-service/ will be directed to /http://analysis-service:8083/analysis-service/.

After the configuration file (nginx.conf) is created, we will deploy the Nginx web server in a Docker container. For this, we create a Dockerfile as follows:

# latest nginxFROM nginx# copy custom configuration fileCOPY nginx.conf /etc/nginx/nginx.conf# expose server portEXPOSE 80# start serverCMD ["nginx", "-g", "daemon off;"]

And we build a Docker image for Nginx web server as follows:

docker image build -t custom-nginx:latest .

Once all Docker images are built, all system can be deployed by running docker-compose up command on the following docker-compose.yml file:

version: '3.7'services:  nginx_server:    image: custom-nginx    ports:      - '80:80'    networks:      - demo-network    depends_on:      - "search-service-1"      - "search-service-2"      - "search-service-3"      - "analysis-service"search-service-1:  image: search-service-1  ports:    - '8080:8080'  networks:    - demo-networksearch-service-2:  image: search-service-2  ports:    - '8081:8081'  networks:    - demo-networksearch-service-3:  image: search-service-3  ports:    - '8082:8082'  networks:    - demo-networkanalysis-service:  image: analysis-service  ports:    - '8083:8083'  networks:    - demo-networknetworks:  demo-network:    name: demo-network

Deploying a full-stack Spring boot, Mysql, and React app on Kubernetes with Persistent Volumes and Secrets

2020-04-21T11:06:51.982Z

Introduction

In this article, you’ll learn how to deploy a Stateful app built with Spring Boot, Mysql, and React on Kubernetes. We’ll use a local minikube cluster to deploy the application. Please make sure that you have kubectl and minikube installed in your system.

If you want to Gain In-depth Knowledge on Full Stack Spring Boot, please go through this link Spring Boot Online Training

If you’re new to Kubernetes, I recommend reading the following hands-on guides before reading this one-

Deploying a containerized Go app on Kubernetes
Deploying a multi-container Go app with Redis on Kubernetes

The sample application that we’ll deploy on Kubernetes in this article can be downloaded from Github:

Spring Boot, Mysql, React, Ant design Polling App

It is a full-stack Polling app where users can login, create a Poll, and vote for a Poll.

To deploy this application, we’ll use few additional concepts in Kubernetes called PersistentVolumes and Secrets. Let’s first get a basic understanding of these concepts before moving to the hands-on deployment guide. Let's See How the Kubernetes helps to Spring Boot Training

Kubernetes Persistent Volume

We’ll use Kubernetes Persistent Volumes to deploy Mysql. A PersistentVolume (PV) is a piece of storage in the cluster. It is a resource in the cluster just like a node. The Persistent volume’s lifecycle is independent from Pod lifecycles. It preserves data through restarting, rescheduling, and even deleting Pods.

PersistentVolumes are consumed by something called a PersistentVolumeClaim (PVC). A PVC is a request for storage by a user. It is similar to a Pod. Pods consume node resources and PVCs consume PV resources. Pods can request specific levels of resources (CPU and Memory). PVCs can request specific size and access modes (e.g. read-write or read-only).

Kubernetes Secrets

We’ll make use of Kubernetes secrets to store the Database credentials. A Secret is an object in Kubernetes that lets you store and manage sensitive information, such as passwords, tokens, ssh keys etc. The secrets are stored in Kubernetes backing store, etcd. You can enable encryption to store secrets in encrypted form in etcd.

Deploying Mysql on Kubernetes using PersistentVolume and Secrets

Following is the Kubernetes manifest for MySQL deployment. I’ve added comments alongside each configuration to make sure that its usage is clear to you.

apiVersion: v1
kind: PersistentVolume            # Create a PersistentVolume
metadata:
  name: mysql-pv
  labels:
    type: local
spec:
  storageClassName: standard      # Storage class. A PV Claim requesting the same storageClass can be bound to this volume. 
  capacity:
    storage: 250Mi
  accessModes:
    - ReadWriteOnce
  hostPath:                       # hostPath PersistentVolume is used for development and testing. It uses a file/directory on the Node to emulate network-attached storage
    path: "/mnt/data"
  persistentVolumeReclaimPolicy: Retain  # Retain the PersistentVolume even after PersistentVolumeClaim is deleted. The volume is considered “released”. But it is not yet available for another claim because the previous claimant’s data remains on the volume. 
---    
apiVersion: v1
kind: PersistentVolumeClaim        # Create a PersistentVolumeClaim to request a PersistentVolume storage
metadata:                          # Claim name and labels
  name: mysql-pv-claim
  labels:
    app: polling-app
spec:                              # Access mode and resource limits
  storageClassName: standard       # Request a certain storage class
  accessModes:
    - ReadWriteOnce                # ReadWriteOnce means the volume can be mounted as read-write by a single Node
  resources:
    requests:
      storage: 250Mi
---
apiVersion: v1                    # API version
kind: Service                     # Type of kubernetes resource 
metadata:
  name: polling-app-mysql         # Name of the resource
  labels:                         # Labels that will be applied to the resource
    app: polling-app
spec:
  ports:
    - port: 3306
  selector:                       # Selects any Pod with labels `app=polling-app,tier=mysql`
    app: polling-app
    tier: mysql
  clusterIP: None
---
apiVersion: apps/v1
kind: Deployment                    # Type of the kubernetes resource
metadata:
  name: polling-app-mysql           # Name of the deployment
  labels:                           # Labels applied to this deployment 
    app: polling-app
spec:
  selector:
    matchLabels:                    # This deployment applies to the Pods matching the specified labels
      app: polling-app
      tier: mysql
  strategy:
    type: Recreate
  template:                         # Template for the Pods in this deployment
    metadata:
      labels:                       # Labels to be applied to the Pods in this deployment
        app: polling-app
        tier: mysql
    spec:                           # The spec for the containers that will be run inside the Pods in this deployment
      containers:
      - image: mysql:5.6            # The container image
        name: mysql
        env:                        # Environment variables passed to the container 
        - name: MYSQL_ROOT_PASSWORD 
          valueFrom:                # Read environment variables from kubernetes secrets
            secretKeyRef:
              name: mysql-root-pass
              key: password
        - name: MYSQL_DATABASE
          valueFrom:
            secretKeyRef:
              name: mysql-db-url
              key: database
        - name: MYSQL_USER
          valueFrom:
            secretKeyRef:
              name: mysql-user-pass
              key: username
        - name: MYSQL_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-user-pass
              key: password
        ports:
        - containerPort: 3306        # The port that the container exposes       
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage  # This name should match the name specified in `volumes.name`
          mountPath: /var/lib/mysql
      volumes:                       # A PersistentVolume is mounted as a volume to the Pod  
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim

We’re creating four resources in the above manifest file. A PersistentVolume, a PersistentVolumeClaim for requesting access to the PersistentVolume resource, a service for having a static endpoint for the MySQL database, and a deployment for running and managing the MySQL pod.

The MySQL container reads database credentials from environment variables. The environment variables access these credentials from Kubernetes secrets.

Let’s start a minikube cluster, create kubernetes secrets to store database credentials, and deploy the Mysql instance:

Starting a Minikube cluster

$ minikube start

Creating the secrets

You can create secrets manually from a literal or file using the kubectl create secret command, or you can create them from a generator using Kustomize.

In this article, we’re gonna create the secrets manually:

$ kubectl create secret generic mysql-root-pass --from-literal=password=R00t
secret/mysql-root-pass created

$ kubectl create secret generic mysql-user-pass --from-literal=username=callicoder --from-literal=password=c@ll1c0d3r
secret/mysql-user-pass created

$ kubectl create secret generic mysql-db-url --from-literal=database=polls --from-literal=url='jdbc:mysql://polling-app-mysql:3306/polls?useSSL=false&serverTimezone=UTC&useLegacyDatetimeCode=false'
secret/mysql-db-url created

You can get the secrets like this -

$ kubectl get secrets
NAME                         TYPE                                  DATA   AGE
default-token-tkrx5          kubernetes.io/service-account-token   3      3d23h
mysql-db-url                 Opaque                                2      2m32s
mysql-root-pass              Opaque                                1      3m19s
mysql-user-pass              Opaque                                2      3m6s

You can also find more details about a secret like so -

$ kubectl describe secrets mysql-user-pass
Name:         mysql-user-pass
Namespace:    default
Labels:       <none>
Annotations:  <none>

Type:  Opaque

Data
====
username:  10 bytes
password:  10 bytes

Deploying MySQL

Let’s now deploy MySQL by applying the yaml configuration -

$ kubectl apply -f deployments/mysql-deployment.yaml
service/polling-app-mysql created
persistentvolumeclaim/mysql-pv-claim created
deployment.apps/polling-app-mysql created

That’s it! You can check all the resources created in the cluster using the following commands -

$ kubectl get persistentvolumes
NAME       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                    STORAGECLASS   REASON   AGE
mysql-pv   250Mi      RWO            Retain           Bound    default/mysql-pv-claim   standard                30s

$ kubectl get persistentvolumeclaims
NAME             STATUS   VOLUME     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
mysql-pv-claim   Bound    mysql-pv   250Mi      RWO            standard       50s

$ kubectl get services
NAME                TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)    AGE
kubernetes          ClusterIP   10.96.0.1    <none>        443/TCP    5m36s
polling-app-mysql   ClusterIP   None         <none>        3306/TCP   2m57s

$ kubectl get deployments
NAME                READY   UP-TO-DATE   AVAILABLE   AGE
polling-app-mysql   1/1     1            1           3m14s

Logging into the MySQL pod

You can get the MySQL pod and use kubectl exec command to login to the Pod.

$ kubectl get pods
NAME                                 READY   STATUS    RESTARTS   AGE
polling-app-mysql-6b94bc9d9f-td6l4   1/1     Running   0          4m23s

$ kubectl exec -it polling-app-mysql-6b94bc9d9f-td6l4 -- /bin/bash
root@polling-app-mysql-6b94bc9d9f-td6l4:/#

Deploying the Spring Boot app on Kubernetes

All right! Now that we have the MySQL instance deployed, Let’s proceed with the deployment of the Spring Boot app at Spring Boot Online Course

Following is the deployment manifest for the Spring Boot app -

---
apiVersion: apps/v1           # API version
kind: Deployment              # Type of kubernetes resource
metadata:
  name: polling-app-server    # Name of the kubernetes resource
  labels:                     # Labels that will be applied to this resource
    app: polling-app-server
spec:
  replicas: 1                 # No. of replicas/pods to run in this deployment
  selector:
    matchLabels:              # The deployment applies to any pods mayching the specified labels
      app: polling-app-server
  template:                   # Template for creating the pods in this deployment
    metadata:
      labels:                 # Labels that will be applied to each Pod in this deployment
        app: polling-app-server
    spec:                     # Spec for the containers that will be run in the Pods
      containers:
      - name: polling-app-server
        image: callicoder/polling-app-server:1.0.0
        imagePullPolicy: IfNotPresent
        ports:
          - name: http
            containerPort: 8080 # The port that the container exposes
        resources:
          limits:
            cpu: 0.2
            memory: "200Mi"
        env:                  # Environment variables supplied to the Pod
        - name: SPRING_DATASOURCE_USERNAME # Name of the environment variable
          valueFrom:          # Get the value of environment variable from kubernetes secrets
            secretKeyRef:
              name: mysql-user-pass
              key: username
        - name: SPRING_DATASOURCE_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-user-pass
              key: password
        - name: SPRING_DATASOURCE_URL
          valueFrom:
            secretKeyRef:
              name: mysql-db-url
              key: url
---
apiVersion: v1                # API version
kind: Service                 # Type of the kubernetes resource
metadata:                     
  name: polling-app-server    # Name of the kubernetes resource
  labels:                     # Labels that will be applied to this resource
    app: polling-app-server
spec:                         
  type: NodePort              # The service will be exposed by opening a Port on each node and proxying it. 
  selector:
    app: polling-app-server   # The service exposes Pods with label `app=polling-app-server`
  ports:                      # Forward incoming connections on port 8080 to the target port 8080
  - name: http
    port: 8080
    targetPort: 8080

The above deployment uses the Secrets stored in mysql-user-pass and mysql-db-url that we created in the previous section.

Let’s apply the manifest file to create the resources -

$ kubectl apply -f deployments/polling-app-server.yaml
deployment.apps/polling-app-server created
service/polling-app-server created

You can check the created Pods like this -

$ kubectl get pods
NAME                                  READY   STATUS    RESTARTS   AGE
polling-app-mysql-6b94bc9d9f-td6l4    1/1     Running   0          21m
polling-app-server-744b47f866-s2bpf   1/1     Running   0          31s

Now, type the following command to get the polling-app-server service URL -

$ minikube service polling-app-server --url
http://192.168.99.100:31550

You can now use the above endpoint to interact with the service -

$ curl http://192.168.99.100:31550
{"timestamp":"2019-07-30T17:55:11.366+0000","status":404,"error":"Not Found","message":"No message available","path":"/"}

Deploying the React app on Kubernetes

Finally, Let’s deploy the frontend app using Kubernetes. Here is the deployment manifest -

apiVersion: apps/v1             # API version
kind: Deployment                # Type of kubernetes resource
metadata:
  name: polling-app-client      # Name of the kubernetes resource
spec:
  replicas: 1                   # No of replicas/pods to run
  selector:                     
    matchLabels:                # This deployment applies to Pods matching the specified labels
      app: polling-app-client
  template:                     # Template for creating the Pods in this deployment
    metadata:
      labels:                   # Labels that will be applied to all the Pods in this deployment
        app: polling-app-client
    spec:                       # Spec for the containers that will run inside the Pods
      containers:
      - name: polling-app-client
        image: callicoder/polling-app-client:1.0.0
        imagePullPolicy: IfNotPresent
        ports:
          - name: http
            containerPort: 80   # Should match the Port that the container listens on
        resources:
          limits:
            cpu: 0.2
            memory: "10Mi"
---
apiVersion: v1                  # API version
kind: Service                   # Type of kubernetes resource
metadata:
  name: polling-app-client      # Name of the kubernetes resource
spec:
  type: NodePort                # Exposes the service by opening a port on each node
  selector:
    app: polling-app-client     # Any Pod matching the label `app=polling-app-client` will be picked up by this service
  ports:                        # Forward incoming connections on port 80 to the target port 80 in the Pod
  - name: http
    port: 80
    targetPort: 80

Let’s apply the above manifest file to deploy the frontend app -

$ kubectl apply -f deployments/polling-app-client.yaml
deployment.apps/polling-app-client created
service/polling-app-client created

Let’s check all the Pods in the cluster -

$ kubectl get pods
NAME                                  READY   STATUS    RESTARTS   AGE
polling-app-client-6b6d979b-7pgxq     1/1     Running   0          26m
polling-app-mysql-6b94bc9d9f-td6l4    1/1     Running   0          21m
polling-app-server-744b47f866-s2bpf   1/1     Running   0          31s

Type the following command to open the frontend service in the default browser -

$ minikube service polling-app-client

You’ll notice that the backend api calls from the frontend app is failing because the frontend app tries to access the backend APIs at localhost:8080. Ideally, in a real-world, you’ll have a public domain for your backend server. But since our entire setup is locally installed, we can use kubectl port-forward command to map the localhost:8080 endpoint to the backend service -

$ kubectl port-forward service/polling-app-server 8080:8080

That’s it! Now, you’ll be able to use the frontend app. Here is how the app looks like -

10 Useful Tips For Ruby On Rails Developers

2020-04-20T13:59:15.671Z

Rails is a model-view-controller Web framework written in the Ruby programming language. One of its great appeals is being able to quickly crank out CRUD-based Web applications. A big advantage of Rails over other frameworks is that it values convention over configuration. If you follow the correct conventions, you can avoid lengthy configuration of files, and things just work! Therefore, you spend less time writing boring config files and more time focusing on business logic.

In the overview below we present 10 useful tips, ideas, and resources for Ruby on Rails-developers (both newbies and professionals). Please feel free to share your tips, ideas and suggestions in the comments to this post!

If you want to Gain In-depth Knowledge on Ruby On Rails, please go through this link Ruby On Rails Training

1. Plug-Ins Save Time

Rails has a well defined plug-in structure that enables you to easily install and use plug-ins in your application. David Heinemeier Hansson, the father of Rails, once stated that he uses five to six plug-ins in each Rails application.

There’s an old nugget of developer wisdom that “the best code is no code at all.” Part of what makes us so productive when developing in Rails is that all the code that we don’t have to write because someone else in the community has already written a plug-in that provides the functionality we need.

There are a few ways to install a plug-in in Rails, however the most common is using script:

# Install from a git reposcript/plugin install git://github.com/mislav/will_paginate.git# Install from a urlscript/plugin install http://topfunky.net/svn/plugins/calendar_helper

You can save yourself a ton of time and hassle by becoming good at searching the Web (and especially the almighty GitHub). A couple of places to find plug-ins are Core Rails, Railsify and Rails Plug-in Directory. Need to integrate with an existing API or consume some kind of standard format data? Need tagging, pagination, or another common Web application feature? Odds are that some great Rails or Ruby developer out there already has a project going that will get you at least most of the way there.

2. Testing Is Fun And Easy With Rspec

For most people, the word “test” brings back scary memories of school exams. When working with Rails, however, automated testing can make your development experience much more enjoyable. While lots of people have strong, nearly religious, opinions about them, at their core, automated tests are just little helper programs you write that run bits of your main code to make sure they do the right thing. When done right, testing will improve your workflow and increase your confidence in the results.

Rails ships with a test framework baked right in, but for the last couple of years all the cool kids have been using an alternative called Rspec. Rspec’s biggest advantage is its syntax for specifying tests:

describe "My Cool library" do before do    @cool = Cool.new end  it "should be full of penguins." do    @cool.get_penguins!    @cool.penguin_count.should == 10  end  it "should melt if it gets too warm"end

What’s great about Rspec’s syntax is how much English it uses. The describe block that sets the context and each assertion within it takes strings that you use to explain what your code should do. Often, this is the most important stage: you sit down to write the assertion, getting as far as you can, and then you think, “Right, what should this code actually do then?”

Because Rspec lets you leave off the block that implements the assertion (as in the second melt example), you can quickly brainstorm all of your functionality, and then go back and implement the tests later as you write the code. In the meantime, Rspec will consider those tests as “pending” and give you little reminders about them in your test runs.

Besides helping you write code in the first place, another great thing about tests is that, once you have enough of them, they let you see how all of your code is related, making it easy to know if your recent change broke anything else in your application. Rspec makes it easy to get good test coverage through the use of custom generators that create the tests right along with the rest of your code:

$ script/generate rpsec_scaffold MyModel

Once you’ve got tests to ensure that the basic functionality works successfully, you can make changes and add new code with confidence without worrying about introducing invisible bugs. As long as you run your tests regularly, you’ll know as soon as you break something. And as GI Joe taught us, knowing is half the battle!

3. Save Time, Use Rake

Projects often include more than just application-specific code. Sample data have to be created, Web services have to be queried, files have to be moved, code snippets rewritten, etc. Resist the urge to shell script or to cram in a migration or controller. Use Rake. It rocks!

Rake is a build tool written in Ruby, very similar to make. Rails projects have several Rake tasks already defined; to see these, run the rake -T command.

macbook$ rake -Trake data:bootstrap     # load in some basic data [caution: will nuke and replcace cate...rake db:create:all      # Create all the local databases defined in config/database.ymlrake db:drop         # Drops the database for the current RAILS_ENV...rake ts:run          # Stop if running, then start a Sphinx searchd daemon using Thi...rake ts:start        # Start a Sphinx searchd daemon using Thinking Sphinx's settingsrake ts:stop         # Stop Sphinx using Thinking Sphinx's settings

Adding your own Rake tasks is quite easy. In the example below, you see that the task is name-spaced and has a description and task name, allowing you to write in Ruby.

namespace :data do desc "load in some basic data [caution: will nuke and replcace categories, categorizations and inventory items]"  task :bootstrap => :environment do    # clean out existing:    [Category, Categorization, InventoryItem].each{|m| m.find(:all).each{|i| i.destroy}}    InventoryItem.create! :name => "Compass"    c = Category.create! :name => "Basic Apparel"    ["Men’s Heavyweight Cotton T",    "Men’s Heavyweight Polo",    "Women’s Organic Cotton Fitted T",    "Women’s Fitted Polo",    "Children’s T-Shirt",    "Jr’s Distressed Hoodie",    "Hemp Messenger Bag"].each do |name|      c.inventory_items.create! :name => name    end   ...end

4. Track Application Exceptions

Exceptions happen, and when they do, you want to know about them! Your client shouldn’t be the one telling you that a problem has occurred; you should already be aware of the issue and working to resolve it. Exception notification has been available in Rails for a while. There are exception notification plug-ins that make it easy to be notified. However, some services such as Airbrake Bug Tracker and Get Exceptional add a lot of value to your application.

Both of these services are easy to install and provide a great UI for tracking your exceptions. You can even sign up for a free account to try things out.

By centralizing the application exceptions, you are able to see how frequently these exceptions occur, what environment they occur in (a particular browser? a particular location?), what parameters were present and the full stack trace. This centralization of data helps you see patterns and resolve the issue more quickly, which results in a better application and happier users.

5. Mix And Match Between Frameworks And Servers With Rails On Rack

As of version 2.3, Rails runs on top of Rack. Rack makes it possible to mix and match between Ruby Web frameworks and servers. If you’re using a framework that supports it (like Rails, Sinatra, Camping, etc), you can choose from any of the servers that do also (Mongrel, Thin, Phusion Passenger, etc.), and vice versa.

In addition to introducing all kinds of new options for deployment, this change means that Rails now has access to the exciting world of Rack middleware. Because Rack lives at the intersection of your app and your server, it can provide all kinds of common functionality directly. A great example of this is Rack::Cache.

Rack::Cache provides a caching layer for your application that you control simply by sending the correct headers in your responses. In other words, all you have to do is install a bit of code in the Rack config file:

require 'rack/cache'use Rack::Cache,  :metastore => 'file:/tmp/rack_meta_dir',  :entitystore => 'file:/tmp/rack_body_dir',  :verbose => true

And make sure your controller actions send the right headers (for example, by setting request.headers[“Cache-Control”]) and Bam!, you’ve got caching.

6. Easy Data Dumping

You’ll often need to get data from production to dev or dev to your local or your local to another developer’s local. One plug-in we use over and over is Yaml_db. This nifty little plug-in enables you to dump or load data by issuing a Rake command. The data is persisted in a yaml file located in db/data.yml. This is very portable and easy to read if you need to examine the data.

rake db:data:dumpexample data found in db/data.yml---campaigns:  columns:  - id  - client_id  - name  - created_at  - updated_at  - token records:  - - "1"    - "1"    - First push    - 2008-11-03 18:23:53    - 2008-11-03 18:23:53    - 3f2523f6a665  - - "2"    - "2"    - First push    - 2008-11-03 18:26:57    - 2008-11-03 18:26:57    - 9ee8bc427d94

7. Keep Your Constants In One Place

All applications have constants, variables that are defined with data that don’t change, such as the name of the application, the tagline, values for crucial options, etc. We use the Rails initializer feature to define a config/initializers/site_config.rbfor housing these constants. By using this convention, all developers on a project know exactly where to look for the constants and can quickly make changes.

Many people have questions about when to put a constant in the site_config.rb instead of the class it is used in. For a constant that are only used in a single class, we suggest putting it in that class. However, if the constant is used in more than one location, put it in the site_config.rb. For more on constants, have a look at Rubylearning.

# File config/initializers/site_config.rbREPORT_RECIPIENT = 'jenn@scg.com'REPORT_ADMIN = 'michael@scg.com'

8. Console For Working On Code

Sometimes you may have code that you’re curious about. Will it work this way? What’s the output? What can I change? Rails ships with a wonderful tool called console. By running script/console you will enter an interactive environment where you can access your Rails code just as though the application were running.

This environment is incredibly helpful. It is often used in production environments at times to quickly peek at data without having to log in to the database. To do this in a production environment, use script/console RAILS_ENV=production:

macbook$ ./script/consoleLoading development environment (Rails 2.1.1)>> a = Album.find(:first)=> #>>

9. Ugly Views Getting You Down? Try Haml.

Views are how your Rails application generates the HTML pages your visitors actually see and use. By default, Rails uses the ERb templating system to let you embed bits of Ruby in your markup so that you can insert your data as needed. However, recent versions of Rails let you take your pick of templating languages, and nowadays the Ruby interwebs have been all abuzz about an alternative system called Haml.

Haml is marketed as “markup Haiku.” Its CSS-inspired syntax lets you focus on the semantics of your data rather than worrying about closing all the angle brackets that come with using ERb and HTML.

For comparison, here’s a bit of markup in standard ERb:

<%= print_date %><%= current_user.address %><%= current_user.email %><%= h current_user.bio %>

And here’s the equivalent in Haml:

#profile  .left.column    #date= print_date    #address= current_user.address  .right_column    #email= current_user.email    #bio= h(current_user.bio)

Haml’s not for everyone, and many people will find this syntax quite alien. But if you value concision and are fluent in CSS, Haml may be just the ticket.

10. Know Where To Watch What’s Happening In Rails

Rails and Ruby both have large and active communities that constantly generate changes, improvements and new projects. Trying to keep up with all the activity can be daunting, but it’s essential if you want to benefit from the community’s best work and continue to increase your Rails and Ruby knowledge.

Sravan Cynixit

How To Work with Arrays in Ruby

Introduction

Creating an Array

Accessing Items in Arrays

Adding Elements

Removing Elements

Modifying Existing Elements

Iterating Over an Array

Conclusion

Spring Boot And Spring MVC Detailed Comparision As Of 2020 It Eliminates All Your Doubts

Introduction

What is Spring MVC?

What is Spring Boot?

Comparing Spring Boot and Spring MVC

Spring MVC

Spring Boot

Conclusion

Introduction to Spring Framework

Introduction:

Features of te Spring Framework:

Evolution of Spring Framework

Spring Framework Architecture

Spring Framework Modules

Spring Boot Security + JWT Hello World Example

Develop a Spring Boot Application That Exposes a GET REST API

Spring Security and JWT Configuration

Generating JWT

JwtTokenUtil

JWTUserDetailsService

JwtAuthenticationController

JwtRequest

JwtResponse

JwtRequestFilter

JwtAuthenticationEntryPoint

WebSecurityConfig

Top 10 Spring Boot Interview Questions

Prepare for your next Spring Boot interview with these common interview questions.

Netflix OSS and Spring Boot — Coming Full Circle

The autoload Method in Ruby

autoload registration & lazy loading

The Module#autoload? method

The Module#autoload method behind the scene

Deploying Spring Boot Applications

Deploying in Java Archive (JAR) as a standalone application

Deploying as Web Application Archive (WAR) into a servlet container

Deploying in Docker Container

Deploying behind NGINX web server — direct setup

Load balancing

Deploying behind NGINX web server — containerized setup

Deploying a full-stack Spring boot, Mysql, and React app on Kubernetes with Persistent Volumes and Secrets

Introduction

Kubernetes Persistent Volume

Kubernetes Secrets

Deploying Mysql on Kubernetes using PersistentVolume and Secrets

Starting a Minikube cluster

Creating the secrets

Deploying MySQL

Logging into the MySQL pod

Deploying the Spring Boot app on Kubernetes

Deploying the React app on Kubernetes

10 Useful Tips For Ruby On Rails Developers

1. Plug-Ins Save Time

2. Testing Is Fun And Easy With Rspec

3. Save Time, Use Rake

4. Track Application Exceptions

5. Mix And Match Between Frameworks And Servers With Rails On Rack

6. Easy Data Dumping

7. Keep Your Constants In One Place

8. Console For Working On Code

9. Ugly Views Getting You Down? Try Haml.

10. Know Where To Watch What’s Happening In Rails

`autoload` registration & lazy loading

The `Module#autoload?` method

The `Module#autoload` method behind the scene