Spring 2
                     Why Should We Use the Spring Framework in Java
We'll discuss Spring's primary value proposition in this article 
as one  of the most well-liked Java frameworks.
More significantly, we'll endeavor to comprehend why Spring 
is our  preferred framework. In our prior courses, we have 
extensively  discussed the details of Spring and its 
component pieces. We'll  therefore omit the opening "how" 
sections and concentrate instead on  the "whys."
Why Use Any Framework, Second?
Let's first establish why we need to utilize any 
framework at all  before we start talking specifically about 
Spring.
A wide range of applications can be supported by a 
general-purpose  programming language like Java. Not to add 
that Java is always being  improved and worked on.
Moreover, Java is supported in this area by a huge number 
of open  source and paid libraries.
So why do we still require a framework?
In all honesty, using a framework isn't always required to 
complete a  task. But using one is frequently advised for a 
number of reasons:
● helps us concentrateon the main goal rather
than the  accompanying boilerplate
● combines decades of knowledge into design patterns.
● enables us to follow industry and governing standards
● lowers the application's overall cost of ownership
Even though we haven't even begun to scratch the surface, 
we must  admit that the advantages are hard to overlook. 
However, it can't be  all good, so what's the problem:
● makes us have to write an application in a certain way
● ties together with a certain language and library version
Quick Ecosystem Overview for Spring
Around 2003, when Java Enterprise Edition was rapidly 
evolving and  creating an enterprise application was both 
exciting and  time-consuming, Spring was created.
As an Inversion of Control (IoC) container for Java, Spring got 
its  beginnings. We still primarily associate Spring with it, and 
it actually  serves as the foundation for both the framework 
and additional  projects built on top of it.
Spring Framework
The spring framework is broken up into modules, which 
makes it  relatively simple to use individual components in 
any application:
Core:
The Inversion of Control (IoC) container from the Spring 
Framework is  the most important of these. The Spring 
Framework's IoC container is  covered in detail, and then the 
Aspect-Oriented Programming (AOP)  tools are covered in 
detail. The 80 percent sweet spot of AOP needs  in Java 
enterprise programming is well addressed by the Spring  
Framework's own AOP framework, which is theoretically 
simple to  understand.
1. The IoC Container:
Only function Object() { [native code] } arguments, 
arguments to  a factory method, or attributes set on the 
object instance after it is  created or returned from a factory 
method are used by objects to  describe their dependencies 
(i.e., the other objects they work with).  When the container 
produces the bean, it then injects those  dependencies.
1.Simpler incorporation of Spring's AOP functions
2.Handling message resources (for use in 
internationalization)
3.Event coverage
4.Contexts that are particular to the application layer, such 
as the  Web Application Context used in web applications.
2. Resources:
● The Java.net standard. Unfortunately, not all 
access to  low-level resources can be fully supported by 
URL class and  standard handlers for different URL 
prefixes. For instance, there  isn't a defined URL 
implementation that can be used to reach a  resource 
that must be located relative to a ServletContext or on  
the classpath.
● The URL interface still lacks some desirable 
functionality, such  as a way to check for the existence of 
the resource being pointed  to, despite the fact that it is 
possible to register new handlers for  specialized URL 
prefixes (similar to existing handlers for prefixes  like 
http:). This is generally quite complicated
Data Access:
The extensive overview of the various data access 
frameworks and  technologies that the Spring Framework 
1co. nTnraenctssa cwtiiothn  Misa nfaoglloewmeedn t:by a  discussion of Spring's 
complete transaction management capabilities.
One of the strongest arguments for using the Spring 
Framework is its  extensive transaction support. The following 
advantages of the Spring
Framework's consistent abstraction for transaction 
management are  provided:
2. Support for DAO
The goal of Spring's Data Access Object (DAO) support is to 
make it  simple to work consistently with data access 
technologies like JDBC,  Hibernate, or JPA. This allows you to 
code without having to worry  about catching exceptions that 
are exclusive to each of the  aforementioned persistence 
systems, and it also makes switching  between them pretty 
easy.
3. Data Access Using Object Relational Mapping (ORM)
In addition to native support for Hibernate for resource 
management,  data access object (DAO) implementations, 
and transaction  strategies, the Spring Framework now 
enables interaction with the  Java Persistence API (JPA). For 
instance, there is first-rate support for  Hibernate with a 
number of useful IoC capabilities that address many  common 
Hibernate integration concerns.
Web:
Servlet-stack web applications are built on the Servlet 
API and  deployed to Servlet containers. Spring MVC, View 
Technologies,  CORS Support, and WebSocket Support are all 
covered in separate  chapters. Web on Reactive Stack is a 
resource for web applications  using the reactive stack.
1. Spring Web MVC
From the beginning, the Spring Framework has contained 
Spring  Web MVC, the original web framework built on the 
Servlet API.  Although it is more often referred to as "Spring 
MVC," the formal term  "Spring Web MVC" is derived from the 
name of its source module  (spring-web MVC).
2. Testing Servlet API Mocks:
Controllers, filters, and other web components can be unit 
tested by  using mock implementations of Servlet API 
contracts. For more  information, go to Servlet API mock 
objects.
Support for loading Spring configuration in JUnit and TestNG 
tests is  provided by the TestContext Framework, which also 
supports loading  a WebApplicationContext with a 
MockServletContext and caching the  loaded configuration 
effectively across test methods.
Integration:
supports Java Message Service (JMS), Java Management 
Extension  (JMX), and Remote Method Invocation (RMI) 
integration to Enterprise  Java (Remote Method Invocation)
1. Web Services and Remote Access Using Spring
Integration classes for remoting support with different 
technologies are  provided by Spring. The remoting feature 
makes it easier to create  services that can be used remotely 
and are implemented by your  typical POJOs.
2. Integration of Enterprise JavaBeans (EJB)
Spring is frequently used as an alternative to EJB because it is 
a  compact container. We do believe that Spring, as a 
container, in  combination with its rich supporting capabilities 
in the areas of  transactions, ORM, and JDBC access, is a 
superior solution than  delivering identical functionality 
through an EJB container and EJBs  for many, if not most, 
applications and use cases.
Testing:
Enterprise software development must include testing. This 
chapter  focuses on the advantages of the Spring 
Framework's support for  integration testing as well as the 
value that the IoC principle adds to  unit testing.
1. Unit Testing
Compared to how it would be with conventional Java EE 
development,  your code should be less dependent on the 
container thanks to  dependency injection. Your application's 
POJOs should be able to be  tested in JUnit or TestNG tests 
without the use of Spring or another  container, with objects 
created using the new operator.
2. Integration Testing
It's critical to have the ability to conduct certain integration 
testing  without connecting to other enterprise infrastructure 
or deploying to  your application server. By doing this, you 
can test things like:
1. Your Spring IoC container contexts must be correctly 
wired, for  starters.
2. Using JDBC or an ORM tool to access data. The accuracy of 
SQL  statements, Hibernate queries, JPA entity mappings, and 
other  elements might be included in this.