DEV Community: Hamdamboy

Spring Framework Architecture and Runtime Components

Hamdamboy — Fri, 29 May 2020 08:32:12 +0000

The mainly concentrated in this post on the Java/ Spring Framework, we are going to study the important modules of the Spring Framework.
Indeed, briefly inform about Spring Framework Architecture and Runtime components differences, and than implementation source codes.

| More source code in the git, you can use freely open source.

Spring Framework Architecure and Spring Framework Runtime (Figure-1).

Let's defining each components in the Figure-1.

Aspect-Oriented Programming

Aspect Oriented Programming(AOP) is the important part of the Spring Framework. The Aspect-Oriented Programming used for separating cross-cutting concerns (for example logging, security etc.) from the business logic of the application.

Model-View-Controller (MVC)

It an HTTP and servlet-based framework, this provides customization for web applications.

Transaction Management

TM is used to unify several transaction management APIs and to coordinate transactions for Java objects.

Core container

The core container is the heart of Spring framework and all other modules are built on top of it. It provides the dependency injection feature, also is known as inversion of control. This module contains the BeanFactory (an implementation of factory pattern) which creates and manages the life cycle of the various application objects (known as beans) defined in the Spring bean configuration file.

Application context

This module provides various enterprise level services, scheduling, JNDI access, email etc.

Spring DAO

Almost every enterprise application needs to interact with the database. Spring DAO module makes it easy to interact with database by providing an abstraction over low level JDBC tasks like creating a database connection, release it etc.
```
TodoRepository.java

  @Repository
   public interface TodosRepository extends CrudRepository<Todo, Integer> { }
```

ORM

There exist a number of popular object-relational mapping tools like Hibernate, iBatis, JPA etc. Spring ORM module helps in integrating with these tools.
ToDoService.java

      @Service
      @Transactional
      public class TodoService {
      private final TodosRepository todosRepository;
      public TodoService(TodosRepository todosRepository) {
        this.todosRepository = todosRepository;
      }
    public List<Todo> findAll(){
    List<Todo> todos = new ArrayList<>();
    for(Todo todo : todosRepository.findAll()) {
        todos.add(todo);
     }
      return todos;
    }

    public void save(Todo todo){
    todosRepository.save(todo);
  }

    public void delete(int id) {
      Optional<Todo> todo = todosRepository.findById(id);
      todosRepository.delete(todo.get());
    }

     public Optional<Todo> findTodo(int id){
       return todosRepository.findById(id);
     }
  }

Inversion of Control (IoC) or Dependency Injection (DI)

A typical java based enterprise application consists of a number of java classes. To accomplish its designated functionality, each java class (A.java) may depend on one or more other java classes. These other java classes are known as dependencies of the java class A. Generally, each class takes the responsibility to obtain the references of the classes it depends upon. This leads to highly coupled application.
Spring framework helps in developing the loosely coupled applications by delegating the responsibility of acquiring the dependencies of a java class to the Spring container and allowing the java class to focus only on its designated functionality. The Spring container injects the dependencies into the java class as the container is initialized (usually on application start up.)
Dependency injection is also known as inversion of control. Instead of java class obtaining their dependencies from the container, it is the container who is injecting the dependencies in the java class. So there is an inversion of control.

References:

Already Hacked - Security Environment of the System

Hamdamboy — Thu, 14 May 2020 00:43:36 +0000

My system hacked by power (reference video)

How to secure your system ( The mainly )

Spring Boot Security (source code )

Create User entity to store user information
Store the User in our database
Link our User with User Details Interface a. Link user with User Details interface b. Link User repository with User Details Service Interface
Integrate Database Auth in our configuration

Linking with Spring Security

UserDetails (interface) <--- UserDetailsService(interface)

Authentication - Create User Entity

I have a Spring MVC. DO I need JWT to!?

If your application provided business logic and all the necessary UI.
And you just have one application being deployed(war/jar)
And if this is all your customer needs
Then you do not need JWT. Form based security will work just fine.

How to handle Database in Spring Boot

Hamdamboy — Fri, 08 May 2020 01:23:29 +0000

Core data for Spring Boot with Database. Please you may use more source in there link.

This provides Database implementation in the Spring Boot. Especially, we'll briefly inform here concept of Spring, Spring Boot, JDBC, JPA, H2 and result of our experience project(there is link using github).

Spring

The Spring Framework is an application framework and inversion of control container for the Java platform. Spring is HA (high avilability).
Spring Boot

Most Spring Boot applications need minimal Spring configuration. Features. Create stand-alone Spring applications

JPA

JPA (The Java Presistence API) = This module deals with enhanced support for JPA based data access layers.Indeed, the JPA is set of the rules to interfaces.

JPA follows Object-Relation Mapping (ORM). It is a set of interfaces. It also provides a runtime EntityManager API for processing queries and transactions on the objects against the database. It uses a platform-independent object-oriented query language JPQL (Java Persistent Query Language). Why should we use JPA? JPA is simpler, cleaner, and less labor-intensive than JDBC, SQL, and hand-written mapping. JPA is suitable for non-performance oriented complex applications.

API (Application programming interface) is a document that contains a description of all the features of a product or software. It represents classes and interfaces that software programs can follow to communicate with each other. An API can be created for applications, libraries, operating systems, etc.

JPA Implementations JPA is an open-source API. There is various enterprises vendor such as Eclipse, RedHat, Oracle, etc. that provides new products by adding the JPA in them. There are some popular JPA implementations frameworks such as Hibernate, EclipseLink, DataNucleus, etc. It is also known as Object-Relation Mapping (ORM) tool.

JDBC

Java Database Connectivity (JDBC) is an application programming interface (API) for the programming language Java, which defines how a client may access a database.
Architecture of the Project Implementation.

H2

H2 is a relational database management system written in Java. It can be embedded in Java applications or run in client-server mode.

Spring Boot + JPA + Hibernate + MySQL|Oracle

Real project configuration. Source.

Create a Maven Project
You may use your tool(Eclipse, IntelliJ Idea, etc.), this example we used IntelliJ then create a new Maven project and name it SpringJDBC.

At the end of this tutorial, we’ll get the following project structure:

POM.XML

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.10.RELEASE</version>
 </parent>

Configuration DB
Repositories
We define our repositories' interfaces under spring.jdbc.dao. Each repository extends Spring CrudRepository, which provides a default implementation for the basic find, save, and delete methods — so we don’t care about defining implementation classes for them.

Truly there is no difference in implementation. Integrating Spring with Jersey and integrating Jersey with Spring

Hamdamboy — Tue, 07 Apr 2020 02:54:55 +0000

More interesting and arguably references are Jersey and Spring, especially integrating Jersey to Spring, or differ. This article we might response that curiosity. Catch up source code which we implemented Spring and Jersey.
Really there is no difference in implementation. Integrating Spring with
Jersey and integrating Jersey with Spring mean the same thing as far as code
is concerned.

What is Jersey, stands for...?

Briefly inform about Jersey: The Jersey RESTful Web Services framework is open source, production quality, framework for developing RESTful Web Services in Java that provides support for JAX-RS APIs and serves as a JAX-RS (JSR 311 & JSR 339) Reference Implementation.

What is JAX-RS...?

Java API for RESTful Web Services (JAX-RS) is a Java programming language API specification that provides support in creating web services according to the Representational State Transfer (REST) architectural pattern.
JAX-RS uses annotations to simplify the development and deployment of web service clients and endpoints. JAX-RS is an official part of Java EE.

This article assumes you understand Jersey, and are thinking about integrating Spring into your Jersey application. Figure-1. Three-tier application architecture.

Figure-1. Three-tier application architecture.

In this example, the business layer and persistence layer may seem redundant, but in a real application, the service layer also handles the business logic of the domain, not just a simple “find data”, but also “do manipulate data”. The persistence layer should only be concerned with database interactions, and not with any business logic.
In a REST application, there is no presentation layer. But does that mean that this architecture doesn’t apply to REST applications? Absolutely not. We should still adhere to this separation of concerns in REST applications. It is just good design.
With Spring, its REST layer is implemented in its MVC framework. The MVC framework is widely know for its MVC capabilities with the use of controllers. But with a little tweaking of the controllers and the annotations used, the controllers can easily become a REST controller, where instead of return models and views, you are return RESTful representation objects. More valuable information adhere Figure-2. A multi-layered architecture, based on the “Law of Demeter".

Figure-2. Multi-layer architecure.

the first layer is the REST support implemented with Jersey, has the role of a facade and delegates the logic to the business layer
the business layer is where the logic happens
the data access layer is where the communcation with the pesistence storage (in our case the MySql database) takes place

Source code:

 @SpringBootApplication
 public class JerseyApplication implements WebApplicationInitializer {

  public static void main(String[] args) {
    SpringApplication.run(JerseyApplication.class, args);
  }

  @Override
 public void onStartup(ServletContext sc) throws ServletException {
    sc.setInitParameter("contextConfigLocation", "noop");

    AnnotationConfigWebApplicationContext context
            = new AnnotationConfigWebApplicationContext();
    context.register(SpringConfig.class);
    sc.addListener(new ContextLoaderListener(context));
    sc.addListener(new RequestContextListener());
 }

Reference:

Cognitive Control Annotations in Spring Boot

Hamdamboy — Tue, 31 Mar 2020 03:18:18 +0000

Cognitive Control Annotations in Spring boot allows to annotation(s) with appropriate dependency injection.

The article mainly focus on Cognitive Control of annotation(s). Especially, @Annotation (@-at using widely in annotation in Spring), and practical implementation in real project. Indeed, you may use free open source here github.
Just click it

Indeed, we’ll explore list of annotations in Spring in down below.

@SpringBootApplication (see Figure-1. Annotation in Spring Boot)

Annotation indicates a configuration class that declares one or more @Bean methods, and also trigger auto-configuration and component scanning.
This is a convenience annotation that is equivalent to declaring @Configuration, @EnableAutoConfiguration, and @ComponentScan.

Figure-1. Annotation in Spring Boot.

More information in the annotation below in that side.

@EnableAutoConfiguration - enable Spring Boot's auto-configuration mechanism
@CompoenetScan - enable @Component scan on the package where the application is located.
@Configuration - allow to register extra beans in the context or import additional configuration classes.

In addition, we will annotate a method of a bean with @Async will make it execute in a separate thread i.e. the caller will not wait for the completion of the called method. (see Figure-2).
If you have been already working on Spring or Spring Boot Application and you have a requirement to use an Asynchronous mechanism, then these below three quick steps will help to set up.

Figure-2. Async Annotation to a method.

Note that Spring uses the Jackson JSON library to convert GitHub’s JSON response into a User object. The @JsonIgnoreProperties annotation signals Spring to ignore any attributes not listed in the class. This makes it easy to make REST calls and produce domain objects.
In this article, we are only grabbing the name and the blog URL for demonstration purposes.

Figure-3 Architecture Structure of Class. (see more code in github)

What we will build in here?

Indeed, We’ll build a lookup service that queries GitHub user information and retrieves data through GitHub’s API. One approach to scaling services is to run expensive jobs in the background and wait for the results using Java’s CompletableFuture interface. Java’s CompletableFuture is an evolution of the regular Future. It makes it easy to pipeline multiple asynchronous operations merging them into a single asynchronous computation.

The GitHubLookupService class uses Spring’s RestTemplate to invoke a remote REST point (api.github.com/users/), and then convert the answer into a User object. Spring Boot automatically provides a RestTemplateBuilder that customizes the defaults with any auto-configuration bits (i.e. MessageConverter).
The findUser method is flagged with Spring’s @Async annotation, indicating it will run on a separate thread. The method’s return type is CompletableFuture instead of User, a requirement for any asynchronous service. This code uses the completedFuture method to return a CompletableFuture instance which is already completed with a result of the GitHub query.

Running Application

Two ways we can start the standalone Spring boot application. We are using maven so just run the application using ./mvnw spring-boot:run. Or you can build the JAR file with ./mvnw clean package. Then you can run the JAR file:
Below diagram shows and how to run spring boot application from IDE - right click - run as - SpringbootAsyncApplication.main() method as a standalone Java class.

In addition, a list all annotation and brief explanation:

@Autowired
@Qualifier("laptop") this may use component regarding laptop name... (ex>= 
Component("lap1")
@autoconfiguration
-------------------------
@Bean
@Configuration
@Control 
@Component
@ComponentScan
-------------------------
@Data ---> at the class level is provided by Lombok and tells Lombok to 
generate all of those missing methods. 
@DeleteMapping
-------------------------
@EnableAutoConfiguration
@Entity
@EnableWebSecurity
------------------------
@ManyToMany (targetEntity=Ingredient.class_)
@ManyToOne
------------------------
@NotNull 
@NotBlank
@NoArgsConstructor ( access=AccessLevel.PRIVATE, force=true)
------------------------
@GetMapping
-------------------------
@Service
@SpringBootApplication
@SpringBootTest
@Size
@Slf4j - Simple Logging Facade for Java. Lombok's @Slf4j annotation to create 
a free SLF4J Logger object at runtime.
@SessionAttributes
@SuppressWarnings("")
-------------------------
@PostMapping
@PutMapping
@PatchMapping
@PrePersist
@Profile
-------------------------
@RunWith(SpringRunner.class)---> prividing a test runner that guides JUnit in 
running a test. Plugin to JUnit to provide custom.
@Repository
@RequestMapping
@RequiredArgsConstructor
-- ----------------------
@Table
------------------------ 
@Query("")
------------------------
@Valid
------------------------
@WebMvcTest  - set up Spring support for testing Spring MVC. Although it 
could be made to start a server, mocking the mechanics of Spring MVC.

Likewise, you may use API github, just free use it. GithubAPI

Twitter, SMS Services: Spring Boot possible XML Configuration

Hamdamboy — Mon, 30 Mar 2020 02:33:10 +0000

The system configuration is important building real project and interoperable dependency injection. This article we will quickly discuss how to develop a simple Spring boot 2 application using XML based Spring configuration. Indeed, Twitter, SMS, Email systems are proceeding in Java Spring implementation and using XML. Indeed, as usual open source in the github, just use it.

In this example, we don't use either Annotation-based configuration or Java-based configuration, we only use XML based configuration to create and configure beans.
Spring provides a @ImportResource annotation is used to load beans from an applicationContext.xml file into an Application Context.

@ImportResource({"classpath*:applicationContext.xml"})

we are creating a simple message processing spring boot application. Here we are sending a message using different services like SMSService, TwitterService, and EmailService. We will configure message service beans in applicationContext.xml file and we will load beans using @ImportResource annotation as (see more source explanation github). Figure -1. XML configuration in Spring Boot.

Figure-1. XML Configuration in Spring Boot

The applicationContext.xml File

There is simplify source code in applicationContext.xml file:
> * Source code

      <?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:context="http://www.springframework.org/schema/context"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context.xsd">
      <bean id ="emailService"
      class="spring.configure.service.EmailService" />
      <bean id="sMSService"
      class="spring.configure.service.SmsService" />
      <bean id="twitterService"
      class="spring.configure.service.TwitterService" />
      <bean id="messageProcessor"
      class="spring.configure.service.MessageProcessorImpl">
      <property name="messageService" ref="twitterService"></property>
      </bean>
      </beans>

The essential point is you may update inside XML source code <bean id ="emailService". in your main folder address and work-space.

Spring Boot: Auto Configuration and Projects

Hamdamboy — Thu, 19 Mar 2020 07:03:11 +0000

What is the Spring Boot?

Spring Boot is basically an extension of the Spring framework which eliminated the boilerplate configurations required for setting up a Spring application.
Indeed, you may find source code github, open source.

It takes an opinionated view of the Spring platform which paved the way for a faster and more efficient development eco-system.

These components, or beans, are wired together inside the Spring application context to make a complete application,much like bricks, mortar, timber, nails, plumbing, and wiring are bound together to make a house.

The act of wiring beans together is based on a pattern known as # dependency injection (DI). Rather than have components create and maintain the lifecycle of other beans that they depend on, a dependency-injected application relies on a separate entity (the container) to create and maintain all components and inject those into the beans that need them. This is done typically through constructor arguments or property accessor methods. More information you may download Spring, and Annotation resource.

Spring Boot Primary Goals

Provide a radically faster and widely accessible getting-started experience for all Spring development. Be opinionated out of the box but get out of the way quickly as requirements start to diverge from the defaults.

Provide a range of non-functional features that are common to large classes of projects (such as embedded servers, security, metrics, health checks, and externalized configuration). Absolutely no code generation and no requirement for XML configuration.
Key Spring Boot features. Let me a list of a few key features of the Spring boot and we will discuss each:

KEY FEATURES briefly

(Step-1) Spring Boot starters
(Step-2) Spring Boot auto-configuration
(Step-3) Elegant configuration management
(Step-4) Spring Boot actuator
(Step-5) Easy-to-use embedded servlet container support

(Step-1) Spring Boot starters

The Spring Initialiser is both a browser-based web application and a REST API, which can produce a skeleton Spring project structure that you can flesh out with whatever functionality you want. Several ways to use Spring Initialiser follow:

* From the web application at http://start.spring.io
* From the command line using the curl command
* From the command line using the Spring Boot command-line interface
* When creating a new project with Spring Tool Suite
* When creating a new project with IntelliJ IDEA
* When creating a new project with NetBeans

For instance, the spring-boot-starter-data-jpa starter module includes all the dependencies required to use Spring Data JPA, along with Hibernate library dependencies, as Hibernate is the most commonly used JPA implementation.

(Step-2) Spring Boot auto-configuration

Spring comes with a powerful web framework known as Spring MVC. At the center of Spring MVC is the concept of a controller, a class that handles requests and responds with information of some sort.
Spring Boot takes an opinionated view of the application and configures various components automatically, by registering beans based on various criteria. The criteria can be:

Availability of a particular class in a classpath
Presence or absence of a Spring bean
Presence of a system property
An absence of a configuration file

Spring MVC

For example, if you have the spring-webmvc dependency in your classpath, Spring Boot assumes you are trying to build a SpringMVC-based web application and automatically tries to register Dispatcher Servlet if it is not already registered. If you have any embedded database drivers in the classpath, such as H2 or HSQL, and if you haven’t configured a DataSource bean explicitly, then Spring Boot will automatically register a DataSource bean using in-memory database settings.

(Step-3) Elegant configuration management

Spring supports externalizing configurable properties using the @PropertySource configuration.More information you may get .

Spring Boot takes it even further by using the sensible defaults and powerful type-safe property binding to bean properties. Spring Boot supports having separate configuration files for different profiles without requiring many configurations.

(Step-4) Spring Boot actuator

The Spring Boot actuator provides a wide variety of such production-ready features without requiring developers to write much code. Some of the Spring actuator features are:

Can view the application bean configuration details
Can view the application URL mappings, environment details, and configuration parameter values
Can view the registered health check metrics

(Step-5) Easy-to-use embedded servlet container support

Easy to use embedded servlet container supports while building web applications, you need to create WAR type modules and then deploy them on external servers like Tomcat, WildFly, etc. But by using Spring Boot, you can create a JAR type module and embed the servlet container in the application very easily so that the application will be a self-contained deployment unit. Also, during development, you can easily run the Spring Boot JAR type module as a Java application from the IDE or from the command-line using a build tool like Maven or Gradle.
Servlet Containers
Servlet vs. Reactive more details

How to handle Default Context Path

How to Change the Default Context Path?
There are several ways to change the default context path.
Using application.properties File

/src/main/resources/application.properties > server.port=8080 > server.servlet.context-path=/springboot2webapp

By default, the context path is “/”. To change the context path, override and update server.servlet.context-path properties. The following examples update the context path from / to /springboot2webapp or

http://localhost:8080/springboot2webapp Just like many other configuration options, the context path in Spring Boot can be changed by setting a property, i.e., server.servlet.context-path.