Spring Framework

1. Overview

Check how to improve the reusability of SW, the Relationship between design pattern and framework, and Spring framework Components.

1.1 Plain Old Java Object (POJO)

• Objects which are no need to inherit specific parent or environment but only JVM. So MyServlet which extends HttpServlet and runs on Web Container is not POJO.

1.2 Portable Service Abstraction (PSA)

• Separate complex low-level implementations, which are transaction, OXM, exception managing, and usage through interfaces.

1.3 Aspect-Oriented Programming (AOP)

• Separate business logic and general concerns, so easily managing common concerns

1.4 Inversion Of Control / Dependency Injection (IoC/DI)

• Offer environment for making extensible object through dynamic external configuration

2. Reusable Code

2.1 Copy And Paste

2.1.1 Pros

Easy to implement

2.1.2 Cons

Need to replace all when correlated codes are changed

2.2 Method Invocation

2.2.1 Pros

Only modifying method contents don't affect other classes

2.2.2 Cons

Coupling Problem: If the method signature is changed, all classes using this method are affected. 

2.3 Class Inheritance

2.3.1 Pros

• Easily propagate methods changes into children only that changes methods signature
• Easily encapsulation relationship between classes like parent and children

2.3.2 Cons

• Changing the method signature of parent need to propagate into all of succeed children

2.4 Aspect-Oriented Programming (AOP)

Separation of Concerns: Cross-cutting concerns

2.4.1 Pros

• Separate common concerns such as logging and transactions from specific business logic Independently
• No need to modify business logic for applying and changing common concerns but only business logics

2.4.2 Cons

• Hard to implement without Framework support

3. Relationship between Design Patten and Framework

3.1 Design Pattern

The reusable solution to a commonly occurring problem within a given context in software design

3.1.1 Motivation

• Minimize changes for changes of logic for changing requirements
• Making code general and intuitive that enhances cooperation within the dev teams

3.2 Framework

An abstraction in which software providing generic functionality, which is non-business functionality such as security, authentication, and transaction, can be selectively changed by additional user-written code, thus providing application-specific software.  

3.2.1 Motivation

• Reduce implementation of non-functionality on every boot project
• Can be focusing on Functional requirement such as business logic
• Offer solutions for repetitive and common problems

3.2.2 Spring framework features

• Container
• DI Support
• AOP Support
• POJO Support
• Transaction Support
• Persistence Support

3.3 Spring framework Components

3.3.1 Spring Core

Basic Container of Spring Framework

BeanFactory exist in this module

3.3.2 AOP

Support Spring AOP

3.3.3 Spring ORM

Support Persistence API such as MyBatis, Hibernate, JPA

3.3.4 Spring DAO

Abstract Layer of JDBC. Support JDBC, Exception management, Transaction management through AOP, etc.

3.3.5 Spring Web

Support Web application. Also, support Integration with other frameworks such as Webwork, Struts, and so on.

3.3.6 Spring Context

BeanFactory Extensional. Support application life cycle events, validation, I18N, etc.

3.3.7 Spring Web MVC

Support to separate Application logic and Web application logic

3.4 Relationship between design pattern and framework

The design pattern is core features in a framework and framework offer advanced features based on design pattern. The design pattern gives some guidelines for project architecture but not offering implementation. But framework offers libraries based on design patterns and some structure for implementation of some functionality. So developers can easily use design patterns through the framework.

4. Framework Components

4.1 Inversion of Control (IoC)

Inversion of Control is a principle in software engineering by which the control of objects or portions of a program is transferred to a container or framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction.

• Contrary way against to traditional program's procedure
• By injecting the beans, which are managed by Spring container, support IoC
• Spring manages beans through metadata such as XML

4.2 Class library

Offers Some parts of the implementation of Spring which are semi-complete. The difference between Library and Frameworks is where is the control of the procedure. Libraries should be invoked from developers, but frameworks are invoking the classes made from developers.

4.3 Design pattern

5. Types of framework

Functionality	Framework
MVC	Spring MVC, Struts 2, Webwork, PalyFramework
ORM	Mybatis, Hibernate, JPA, Spring JDBC
AOP	Spring AOP, AspectJ, JBoss AOP
DI	Spring DI, Google Guice
Build and Library management	Ant + Ivy, Maven, Gradle
Unit Test	JUnit, TestNG, Cactus
Javascript	jQuery, AngularJS, Node.js

6. Reference

https://www.youtube.com/watch?v=yoQwdSEGoK0

https://www.youtube.com/watch?v=j5WlADp5f

https://www.dineshonjava.com/spring-aop-tutorial-with-example-aspect-advice-pointcut-joinpoint/

https://dzone.com/articles/implementing-aop-with-spring-boot-and-aspectj

https://en.wikipedia.org/wiki/Software_design_pattern

https://en.wikipedia.org/wiki/Software_framework

https://www.tutorialspoint.com/spring/spring_ioc_containers.htm

https://www.baeldung.com/inversion-control-and-dependency-injection-in-spring

https://jinpyo900.tistory.com/55

https://bansihaudakari.wordpress.com/frameworks/spring/