MVC

MVC stands for model view controller

It is an architectural pattern
MVC divides a software application in 3 parts:
Model ,view , controller
Client -> server ->database

1. In web application client , server ,database are three important components .

2. It is architectural pattern ,Governs whole architecture of our application
3. It is a kind of design pattern only but it has a much broader scope
4. For example:
5. Normal design patterns are used for solving specific technical problems in our application
6. Whereas an architectural pattern is used for solving larger architectural problems so it basically
attects the entrie
7. Architecture of our application .mvc divides software application in 3 parts model
8. A client wants to see a list of all products which are stored in this database
9. So database stores information about different products so it can be tv mobile phones etc.. and
our client
10. Over here wants to see list of all products which are stored in this database now client sends
request to the server .
11. Let us assume multiple working in the server and each of them has some specific task now
when the request comes to the server there is a guy standing over here at the front (blue)
12. Now blue should take the request from client and now blue will have to go to the
database and get list of products from database and then send the list to the client. But blue does’
not do directly and that is bcoz we have another another guy (red ) who specializes in talking to
the database or interacting with the database so blue will now pass the request information to the
red and red will interact with the database and get all list of products from the database and send
to blue .
13. Now blue has all the data so ideally blue should send all data to the client but the data
which it ahs is raw data so this data might not be in human readable format so client may not
understand it( bcoz it is in plain text data) .
14. So here there is another guy in green who specializes in presenting data to the client now
blue gives the raw data to green and now green will format the data so that it looks attractive to
the user so green take raw data and arrange it ina tabular format or maybe apply some styling to
it so that it appears good and now formatted will be sent to the client.
So this is how an mvc architecture works
1. Red model
2. Green is view
3. Blue is our controller
So we have our model view controller pattern

1. First client send as request to the server then the controller willtake that request to the the model
and the model will interact with the databse and in the process it may also execute some
business logic if required then after getting the data from the database it will pass it to the
controller then the controller will pass the data to our view then the view will format the data and
that formatted data will be sent to the client so this is how architecture works
2. Now each of this 3 components has specific responsibilities so our model it interacts with the
database and it is also responsible for executing business logic so our model basically deals with
data then our view is what used sees on the screen it generates UI or user interface for the user
and
3. Controller takes user input also called as request parameters it also interacts with the model and
view so our controller basically acts as a middle man between our model and view

4. Now consider and java web application then a

5. model will be typically a java class
6. a view would be JSP page or any other presentation technology
7. a controller would be a servlet
8. this is MVC architecture
9. now how these 3 components interact with each other that might be different for different MVC
framework
10. application will divide into 3 components
 design pattern
Design patterns are very popular among software developers. A design pattern is a well-
described solution to a common software problem.
Some of the benefits of using design patterns are:
1. Design patterns are already defined and provide an industry-standard approach to solving a
recurring problem, so it saves time if we sensibly use the design pattern. There are many Java
design patterns that we can use in our Java-based projects.
2. Using design patterns promotes reusability that leads to more robust and highly maintainable
code. It helps in reducing the total cost of ownership (TCO) of the software product.
3. Since design patterns are already defined, it makes our code easy to understand and debug. It
leads to faster development and new members of the team understand it easily.
Java design patterns are divided into three categories - creational, structural,
and behavioral design patterns.
This article serves as an index for all the Java design pattern articles.

Creational Design Patterns

Creational design patterns provide solutions to instantiate an Object in the best possible way
for specific situations.
1. Singleton Pattern
The singleton pattern restricts the instantiation of a Class and ensures that only one instance of
the class exists in the Java Virtual Machine. The implementation of the singleton pattern has
always been a controversial topic among developers.
Note: Learn more about the Singleton Design Pattern.
2. Factory Pattern
The factory design pattern is used when we have a superclass with multiple subclasses and
based on input, we need to return one of the subclasses. This pattern takes out the
responsibility of the instantiation of a Class from the client program to the factory class. We can
apply a singleton pattern on the factory class or make the factory method static.
Note: Learn more about the Factory Design Pattern.
3. Abstract Factory Pattern
The abstract factory pattern is similar to the factory pattern and is a factory of factories. If you
are familiar with the factory design pattern in Java, you will notice that we have a single factory
class that returns the different subclasses based on the input provided and the factory class
uses if-else or switch statements to achieve this. In the abstract factory pattern, we get rid
of if-else block and have a factory class for each subclass and then an abstract factory class
that will return the subclass based on the input factory class.
Note: Learn more about the Abstract Factory Pattern.
4. Builder Pattern
The builder pattern was introduced to solve some of the problems with factory and abstract
Factory design patterns when the object contains a lot of attributes. This pattern solves the
issue with a large number of optional parameters and inconsistent state by providing a way to
build the object step-by-step and provide a method that will actually return the final Object.
Note: Learn more about the Builder Pattern.
5. Prototype Pattern
The prototype pattern is used when the Object creation is costly and requires a lot of time and
resources, and you have a similar Object already existing. So this pattern provides a
mechanism to copy the original Object to a new Object and then modify it according to our
needs. This pattern uses Java cloning to copy the Object. The prototype design pattern
mandates that the Object which you are copying should provide the copying feature. It should
not be done by any other class. However, whether to use the shallow or deep copy of the
object properties depends on the requirements and is a design decision.
Note: Learn more about the Prototype Pattern.

Structural Design Patterns

Structural design patterns provide different ways to create a Class structure (for example, using
inheritance and composition to create a large Object from small Objects).
1. Adapter Pattern

The adapter design pattern is one of the structural design patterns and is used so that two
unrelated interfaces can work together. The object that joins these unrelated interfaces is called
an adapter.
Note: Learn more about the Adapter Pattern.
2. Composite Pattern

The composite pattern is used when we have to represent a part-whole hierarchy. When we
need to create a structure in a way that the objects in the structure have to be treated the same
way, we can apply the composite design pattern.
Note: Learn more about the Composite Pattern.
3. Proxy Pattern
The proxy pattern provides a placeholder for another Object to control access to it. This pattern
is used when we want to provide controlled access to functionality.
Note: Learn more about the Proxy Pattern.
4. Flyweight Pattern
The flyweight design pattern is used when we need to create a lot of Objects of a Class. Since
every Object consumes memory space that can be crucial for low-memory devices (such as
mobile devices or embedded systems), the flyweight design pattern can be applied to reduce
the load on memory by sharing Objects.
String pool implementation in Java is one of the best examples of flyweight pattern
implementation.
Note: Learn more about the Flyweight Pattern.
5. Facade Pattern

The facade pattern is used to help client applications easily interact with the system.
Note: Learn more about the Facade Pattern.
6. Bridge Pattern

When we have interface hierarchies in both interfaces as well as implementations, then the
bridge design pattern is used to decouple the interfaces from the implementation and to hide
the implementation details from the client programs. The implementation of the bridge design
pattern follows the notion of preferring composition over inheritance.
Note: Learn more about the Bridge Pattern.
7. Decorator Pattern

The decorator design pattern is used to modify the functionality of an object at runtime. At the
same time, other instances of the same class will not be affected by this, so the individual
object gets the modified behavior. The decorator design pattern is one of the structural design
patterns (such as adapter pattern, bridge pattern, or composite pattern) and uses abstract
classes or interface with the composition to implement. We use inheritance or composition to
extend the behavior of an object, but this is done at compile-time, and it’s applicable to all the
instances of the class. We can’t add any new functionality to remove any existing behavior at
runtime – this is when the decorator pattern is useful.
Note: Learn more about the Decorator Pattern.

Behavioral Design Patterns

Behavioral patterns provide a solution for better interaction between objects and how to provide
loose-coupling and flexibility to extend easily.
1. Template Method Pattern

The template method pattern is a behavioral design pattern and is used to create a method
stub and to defer some of the steps of implementation to the subclasses. The template method
defines the steps to execute an algorithm, and it can provide a default implementation that
might be common for all or some of the subclasses.
Note: Learn more about the Template Method Pattern.
2. Mediator Pattern

The mediator design pattern is used to provide a centralized communication medium between
different objects in a system. If the objects interact with each other directly, the system
components are tightly-coupled with each other which makes maintainability cost higher and
not flexible to extend easily. The mediator pattern focuses on providing a mediator between
objects for communication and implementing loose-coupling between objects. The mediator
works as a router between objects, and it can have its own logic to provide a way of
communication.
Note: Learn more about the Mediator Pattern
3. Chain of Responsibility Pattern

The chain of responsibility pattern is used to achieve loose-coupling in software design where a
request from the client is passed to a chain of objects to process them. Then the object in the
chain will decide who will be processing the request and whether the request is required to be
sent to the next object in the chain or not.
We know that we can have multiple catch blocks in a try-catch block code. Here
every catch block is kind of a processor to process that particular exception. So when an
exception occurs in the try block, it’s sent to the first catch block to process. If the catch block
is not able to process it, it forwards the request to the next Object in the chain (i.e., the
next catch block). If even the last catch block is not able to process it, the exception is thrown
outside of the chain to the calling program.
Note: Learn more about the Chain of Responsibility Pattern.
4. Observer Pattern
An observer design pattern is useful when you are interested in the state of an Object and
want to get notified whenever there is any change. In the observer pattern, the Object that
watches the state of another Object is called observer, and the Object that is being watched is
called subject.
Java provides an built-in platform for implementing the observer pattern through
the java.util.Observable class and java.util.Observer interface. However, it’s not widely
used because the implementation is limited and most of the time we don’t want to end up
extending a class solely for implementing the observer pattern as Java doesn’t provide multiple
inheritances in classes. Java Message Service (JMS) uses the observer pattern along with the
mediator pattern to allow applications to subscribe and publish data to other applications.
Note: Learn more about the Observer Pattern.
5. Strategy Pattern

Strategy pattern is used when we have multiple algorithms for a specific task, and the client
decides the actual implementation be used at runtime. A strategy pattern is also known as a
policy pattern. We define multiple algorithms and let client applications pass the algorithm to be
used as a parameter.
One of the best examples of this pattern is the Collections.sort() method that takes
the Comparator parameter. Based on the different implementations of comparator interfaces,
the objects are getting sorted in different ways.
Note: Learn more about the Strategy Pattern.
6. Command Pattern
The command pattern is used to implement loose-coupling in a request-response model. In this
pattern, the request is sent to the invoker and the invoker passes it to the
encapsulated command object. The command object passes the request to the appropriate
method of receiver to perform the specific action.
Note: Learn more about the Command Pattern.
7. State Pattern
The state design pattern is used when an Object changes its behavior based on its internal
state. If we have to change the behavior of an Object based on its state, we can have a state
variable in the Object and use if-else condition block to perform different actions based on
the state. The state pattern is used to provide a systematic and loosely-coupled way to achieve
this through context and state implementations.
Note: Learn more about the State Pattern.
8. Visitor Pattern

The visitor pattern is used when we have to perform an operation on a group of similar kinds of
objects. With the help of a visitor pattern, we can move the operational logic from the objects to
another class.
Note: Learn more about the Visitor Pattern.
9. Interpreter Pattern

The interpreter pattern is used to define a grammatical representation of a language and

provides an interpreter to deal with this grammar.
10. Iterator Pattern
The iterator pattern is one of the behavioral patterns and is used to provide a standard way to
traverse through a group of objects. The iterator pattern is widely used in Java Collection
Framework where the iterator interface provides methods for traversing through a Collection.
This pattern is also used to provide different kinds of iterators based on our requirements. The
iterator pattern hides the actual implementation of traversal through the Collection and client
programs use iterator methods.
Note: Learn more about the Iterator Pattern.
11. Memento Pattern
The memento design pattern is used when we want to save the state of an object so that we
can restore it later on. This pattern is used to implement this in such a way that the saved state
data of the object is not accessible outside of the Object, this protects the integrity of saved
state data.
Memento pattern is implemented with two Objects – originator and caretaker. The originator is
the Object whose state needs to be saved and restored, and it uses an inner class to save the
state of Object. The inner class is called “Memento”, and it’s private so that it can’t be
accessed from other objects.
Miscellaneous Design Patterns
There are a lot of design patterns that don’t come under Gang of Four design patterns. Let’s
look at some of these popular design patterns.
1. DAO Design Pattern

The Data Access Object (DAO) design pattern is used to decouple the data persistence logic to
a separate layer. DAO is a very popular pattern when we design systems to work with
databases. The idea is to keep the service layer separate from the data access layer. This way
we implement the separation of logic in our application.
Note: Learn more about the DAO Pattern.
2. Dependency Injection Pattern

The dependency injection pattern allows us to remove the hard-coded dependencies and make
our application loosely-coupled, extendable, and maintainable. We can implement dependency
injection in Java to move the dependency resolution from compile-time to runtime. Spring
framework is built on the principle of dependency injection.
Note: Learn more about the Dependency Injection Pattern.
3. MVC Pattern

Model-View-Controller (MVC) Pattern is one of the oldest architectural patterns for creating web
applications.