What is the Spring MVC hibernate application design?

Question

William Emmanuel Yu · Accepted Answer

Both are using the MVC pattern.

However, MVC's principle architectural design object is to separate the front end aspects from the structure of the data to increase maintainability of the application. It wasn't necessarily designed for performance but to enhance reusability. In some cases, people consider alternatives to MVC approaches such as the Actor model (espoused by Akka) for more messaging driven applications.

The use of Spring Data JPA is definitely an option. It was created to simplify and templatize the creation of data access applications

Madasamy · Answer

Learn about spring framework before you need understand about servlet and jsp.

Let me explain about spring and hipernate.

Spring framework:

Spring framework based on MVC 2 pattern

MVC:

Model view controller is a software architecture design pattern. It provides solution to layer an application by separating three concerns business, presentation and control flow.

* The Model can be some DAO layer or some Service Layers which give some information about request or requested information or Model can be a POJO which encapsulates the application data given by the controller.
 * The View is responsible for rendering the model data and in general it generates HTML output that the client's browser can interpret.
 * The Controller is responsible for processing user requests and building appropriate model and passes it to the view for rendering.
What is Spring?

Spring is great framework for development of Enterprise grade applications. Spring is a light-weight framework for the development of enterprise-ready applications. It provides very simple and rich facilities to integrate various frameworks, technologies, and services in the applications. One of the main reason for using the Spring framework is to keep code as simple as possible. It push the way to develop enterprise applications with loosely coupled simple java beans. For this reason, the spring framework can also be called a Plain Old Java Object (POJO) framework.

Spring is an open-source framework developed by Spring Source, a division of VMware. Spring frame work can summarized in two ways.

* Container-Spring framework can be described as a light weight container, as it does not involve installation, configuration, start and stop activities associated with a container. It is just a simple collection of few Java ARchive (JAR) files that need to be added to the classpath. The Spring Container takes the classes in the application, creates objects, and manages the life cycle of those objects.
 * Framework-Spring framework can be described as an Application Programming Interface(API) containing a large collection of the classes, methods, interfaces, annotations, XML tags that can be used in an application. The API provides a variety of factory and facade classes that help you to use any framework or functionality very easily in your application.
Data Access Using Java Database Connectivity (JDBC): The Spring framework provides a rich support for working with JDBC. A typical JDBC code involves plumbing works, such as creating connection, statements, executing queries and handling exceptions for performing database operations.Spring framework provides a set of classes that take care of these core JDBC operations.

Data Access Using Object Relational Mapping (ORM): There are lots of ORM frameworks, such as Hibernate, Toplink, iBatis etc that can be used in Java Applications. Spring framework provides lots of classes that makes working with ORM is very easy.

Aspect Oriented Programming (AOP): One of the main paradigms that spring uses to provide enterprise services for your applications is AOP. AOP is a mechanism by which you can introduce functionality in your existing code without modifying your design. In short we can say AOP is used to weave cross-cutting functionalities or aspects into the code. The Spring framework uses AOP provides various enterprise services such a transaction and security in an application.

Core Spring Framework: The Core package is the most fundamental part of the framework and provides the IoC and Dependency Injection features. The basic concept here is the BeanFactory, which provides a sophisticated implementation of the factory pattern which removes the need for programmatic singletons and allows you to decouple the configuration and specification of dependencies from your actual program logic.

Spring's MVC: Spring MVC package provides a Model-View-Controller (MVC) implementation for web-applications. Spring's MVC framework is not just any old implementation; it provides a cleanseparation between domain model code and web forms, and allows you to use all the other features of the Spring Framework.

Object XML Mapping: Spring 3.0 introduces the OXM module that was earlier not a part of the core framework. OXM is a mechanism that marshals or converts object into the XML format and vice versa. There are lots of OXM frameworks, such as Caster, Xstream, JiBX, Java API for XML Binding(JAXP), and XMLMeabs. Spring 3.0 provides a uniform API to access any of these OXM frameworks for marshalling and unmarshalling object and XML.

Dependency Injection (DI): The technology that Spring is most identified with is theDependency Injection (DI) flavor of Inversion of Control. The Inversion of Control (IoC) is a general concept, and it can be expressed in many different ways and Dependency Injection is merely one concrete example of Inversion of Control.
What is dependency injection exactly? Let's look at these two words separately. Here thedependency part translates into an association between two classes. For example, class X is dependent on class Y. Now, let's look at the second part, injection. All this means is that class Y will get injected into class X by the IoC. Here we don't need to write lots of code to create the instance of the dependent classes.

Dependency injection promotes loose coupling . It paves the way for the removal of the usal factory and utility classes that we write in our applications.
Look Following:

* The DAO classes use Data Sources which can be injected into them
 * The Service classes may need to add few java beans
Dependency Injection is also known as Inversion of Control or IoC. Ioc refers to the control of creating instances being done by the Spring Container. The control for creating and constructing objects is taken care by the container. The container creates objects and injects then into our applications.

Benefits of Using Spring Framework:

Following is the list of few of the great benefits of using Spring Framework:

* Spring enables developers to develop enterprise-class applications using POJOs. The benefit of using only POJOs is that you do not need an EJB container product such as an application server but you have the option of using only a robust servlet container such as Tomcat or some commercial product.
 * Spring is organized in a modular fashion. Even though the number of packages and classes are substantial, you have to worry only about ones you need and ignore the rest.
 * Spring does not reinvent the wheel instead, it truly makes use of some of the existing technologies like several ORM frameworks, logging frameworks, JEE, Quartz and JDK timers, other view technologies.
 * Testing an application written with Spring is simple because environment-dependent code is moved into this framework. Furthermore, by using JavaBean-style POJOs, it becomes easier to use dependency injection for injecting test data.
 * Spring's web framework is a well-designed web MVC framework, which provides a great alternative to web frameworks such as Struts or other over engineered or less popular web frameworks.
 * Spring provides a convenient API to translate technology-specific exceptions (thrown by JDBC, Hibernate, or JDO, for example) into consistent, unchecked exceptions.
 * Lightweight IoC containers tend to be lightweight, especially when compared to EJB containers, for example. This is beneficial for developing and deploying applications on computers with limited memory and CPU resources.
 * Spring provides a consistent transaction management interface that can scale down to a local transaction (using a single database, for example) and scale up to global transactions (using JTA, for example)
Hipernate framework:

* An ORM Tool
 * Used in the Data layer of the applications
 * Implements JPA (Java Persistence API) i.e its have set of standards that have been prescribed for any persistence of any implementation need to be satisfied to persistence rules in the java that given minimal change of codes means follow the all rules of persistence in later if any change in the ORM tools with minimum change in the code.
Hibernate Architecture

Hibernate Architecture and API-

In this Hibernate Architecture tutorial we include all components. Hibernate Architecture is layered with many objects such persistent object, session factory, transaction factory, connection factory, session, transaction etc. Let see below diagram describing some basic hibernate functionality.

Configuration
It represents a configuration or properties file for Hibernate. The Configuration object is usually created once during application initialization. The Configuration object reads and establishes the properties Hibernate uses to get connected to a database and configure itself for work. A Configuration object is used to create a SessionFactory and then typically is discarded.

SessionFactory 
The SessionFactory is created from a Configuration object, and as its name implies it is a factory for Session objects.The SessionFactory is an expensive object to create. It, like the Configuration object, is usually created during application start up. However, unlike the Configuration object, It should be created once and kept for later use.

The SessionFactory object is used by all the threads of an application. It is a thread safe object. One SessionFactory object is created per database. Multiple SessionFactory objects (each requiring a separate configuration) are created when connecting to multiple databases. The SessionFactory can also provide caching of persistent objects. -Dinesh

Session
Session objects provide the main interface to accomplish work with the database. Persistent objects are saved and retrieved through a Session object. A Session object is lightweight and inexpensive to create. A Session object does the work of getting a physical connection to the database. Session objects maintain a cache for a single application thread (request).

Session objects are not thread safe. Therefore, session objects should not be kept open for a long time.Applications create and destroy these as needed. Typically, they are created to complete a single unit of work, but may span many units. -Dinesh

Transaction 
it represents unit of works.

Query and Criteria
These objects are used to retrieve (and recreate) persistent objects.

Spring with hipernate integeration:

Spring can support in MVC controller,model,view.

hipernate working on model part DAO layer to interact with database.

In application development you need integerate hibernate with spring.

Alan Mellor · Answer

I explain it as three broad parts:

* Hibernate handles data
 * Spring builds the Java app
 * Spring MVC makes the website content.
Hibernate provides a convenient bridge between Java code and the relational database where all your sutomer data is stored. Product lines, prices, orders, customer contact details, shipping addresses will all be stored in this database.

A database is a thing that remembers information even after you stop the eCommerce application from running. Or switch the server computer off.

Spring provides a number of pre-built services that a Java program can use. The most important is a way to take all the separate pieces of Java code you have developed, and assemble them into an eCommerce application.

Spring also helps with other common eCommerce application tasks, like integrating a login system, for example.

Spring MVC is a part of SPring which helps build testable web pages. Your eCommerce site needs a visible part. It will showcase products, and allow orders to be submitted. Spring MVC helps create this part. Specifically, it helps bridge the gap between the web browser and the Java code itself.

So you roughly have a user, with a web browser, sending orders to Spring MVC, which turns these into Java objects for your custom application, which sends these to Hibernate, which prepares them for storage in the database.

ChatGPT · Answer

A Spring MVC application using Hibernate typically follows the Model-View-Controller (MVC) design pattern, integrating Spring Framework's capabilities for web applications with Hibernate's Object-Relational Mapping (ORM) features. Here’s a breakdown of the components and how they interact in such an application design:
Key Components
1. Model:
   - Represents the data and business logic of the application.
   - In a Spring MVC Hibernate application, the model is often represented by Java classes (POJOs) that correspond to database tables.
   - Hibernate is used to manage the persistence of these entities, allowing for CRUD (Create, Read, Update, Delete) operations.
2. View:
   - The view is responsible for rendering the user interface. In Spring MVC, views can be JSP, Thymeleaf, or other templating engines.
   - The view receives data from the controller and displays it to the user.
3. Controller:
   - Controllers handle user requests, interact with the model, and determine which view to render.
   - In a Spring MVC application, controllers are annotated with [code]@Controller[/code] and can use [code]@RequestMapping[/code] to map URLs to specific handler methods.
Application Flow
1. Client Request:
   - The user interacts with the web application, triggering an HTTP request (e.g., submitting a form).
2. Dispatcher Servlet:
   - The Spring Dispatcher Servlet receives the request and routes it to the appropriate controller based on the request mapping.
3. Controller Logic:
   - The controller processes the request, potentially interacting with the model (e.g., fetching data from the database via Hibernate).
   - It may also perform validations and business logic.
4. Service Layer (Optional):
   - Often, a service layer is used to encapsulate business logic. This layer can call repositories or DAOs (Data Access Objects) that use Hibernate for database interactions.
5. Data Access Layer:
   - This layer uses Hibernate to perform database operations. It typically consists of repository or DAO classes annotated with [code]@Repository[/code].
   - Hibernate manages sessions and transactions, allowing for efficient data handling.
6. View Resolution:
   - Once the controller has processed the request and prepared the model data, it returns a view name to the Dispatcher Servlet.
   - The Dispatcher Servlet resolves the view (e.g., a JSP or Thymeleaf template) and combines it with the model data.
7. Response to Client:
   - The view is rendered, and the final HTML is sent back to the user's browser as a response.
Configuration
 * Spring Configuration: The application can be configured using XML or Java-based configuration using [code]@Configuration[/code] classes.
 * Hibernate Configuration: Hibernate is configured in the Spring context using [code]LocalSessionFactoryBean[/code] or [code]EntityManagerFactory[/code] for JPA.
 * DataSource: The connection to the database is established using a DataSource bean, which can be defined in the Spring configuration.
Example Structure
Here's a simple structure of a Spring MVC Hibernate application:
[code]src/main/java/com/example/app
  ├── controller
  │   └── UserController.java
  ├── model
  │   └── User.java
  ├── service
  │   └── UserService.java
  ├── repository
  │   └── UserRepository.java
  └── config
      └── AppConfig.java
src/main/resources
  ├── application.properties
  └── hibernate.cfg.xml
src/main/webapp
  └── WEB-INF
      ├── views
      │   └── user.jsp
      └── web.xml[/code]
Conclusion
Using Spring MVC with Hibernate allows for a clean separation of concerns in web applications, making them easier to maintain and scale. The MVC pattern helps manage user interactions, while Hibernate simplifies database operations, providing a robust framework for enterprise applications.

Razneekant Pardhan · Answer

The Flow of Spring MVC is attache in the Screenshots.

First request is trapped by the Dispatcherservlet, then dispatcher servlet forward to the handlermapping, Handlermapping identify the appropriate handler or controller class. The controller class perform operartion like Dao or business then the resultant page with data will be forward to dispatcherservlet, the dispatcger servlet forward it with logical view name to view resolver, view resolver resolves it and create the view object , it calls the render method on view object then the view page will be displayed

Raghuram Raju Bachu · Answer

To make it non technical i would just use three things for workflow in spring

Model, View and Controller
Model is bascially data storage entity, view is the jsp , html or any front end pages. And controller is where you write the logic.

Explanation (Abstracted view for easier understanding)
So when a user requests a html page, the request goes to RequestMapper of controller(If u don't know about request mapper assume request goes to controller). Suppose there is a Registration(Sign Up) page then in controller class there would be some method to intercept the request for signup page. Now once the method's request mapper name and requested page name match, the method will be executed and logic in the method would be implemented. for instance suppose consider user registers username and password so username and password values would be available in that method. Now the hibernate query would be called in this method and data would be stored to respective java class(model) based table. And finally once the data is stored the query returns back to the method which finally redirects to view saying successfully registered.

Arpit Mandliya · Answer

Spring MVC Hibernate MySQL CRUD example - Java2Blog [ https://java2blog.com/spring-mvc-hibernate-mysql-crud-example/ ]

This example includes a demonstration of Spring MVC Hibernate integration with CRUD operations.

Spring Rest Hibernate example - Java2Blog [ https://java2blog.com/spring-rest-hibernate-example/ ]

Razneekant Pardhan · Answer

Explain your project in an interview which has spring MVC Hibernate Means you have to explain the mvc flow with hibernate , Let me provide the snapshot for mvc flow.

First request is trapped by the Dispatcherservlet, then dispatcher servlet forward to the handlermapping, Handlermapping identify the appropriate handler or controller class. The controller class perform operartion like Dao or business then the resultant page with data will be forward to dispatcherservlet, the dispatcger servlet forward it with logical view name to view resolver, view resolver resolves it and create the view object , it calls the render method on view object then the view page will be displayed,

This is the normal answer you can modify it as you desired.

Neha · Answer

This is a very broad question.

Spring MVC is for a web project.

Hibernate is an ORM which is used to connect and interact with DB.

J2EE means Java Enterprise Edition. It contains all of this and much more.

Typical flow -

Spring MVC-%3EHibernate and using a lot of other J2EE APIs and constructs.

Anonymous · Answer

Spring MVC and Hibernate work in different layers of the popular 3 tier architecture model, comprising of client tier, application tier, and the data tier.

Spring MVC can be used for developing client and application tiers where as Hibernate works with database sitting at data tier.

Coming to the first part of your question i.e. How MVC architecture works… Spring MVC is request driven, and Servlet based framework. The Dispatcher Servlet dispatches requests to the specific controller class, controller executes the business logic, creates the Model (Data to be displayed in Client tier) and sends control back to Dispatcher which intern calls the view. View renders the Model and returns response. (Not included details of Handler and View resolver to make things easy to follow) .

Gongtao Yang · Answer

No, Spring MVC technically is not a design pattern. However, MVC is a pattern.

Here is the relationship between MVC and Spring MVC:

* MVC: Model-View-Controller, a design pattern, can exist in frontend and backend, not limited to language/framework.
 * Spring MVC: Spring’s implementation of MVC pattern. It use annotation to do sperate Model, View, and Controller. It can only be used in the backend with Java.
You can use another thing called “Javax” if you are building something outside of Spring.

In Angular, there is a similar concept called Model-View-ViewModel (MVVM) pattern which is basically angular version of MVC.

Anonymous · Answer

Spring is a web application development framework. To use Spring you need to know at least the following:

1. Java
2. JSP
3. HTML
4. XML
5. Fundamentals of Web Application Development
6. Fundamentals of Model View Controller

Raul Lapeira · Answer

I get this kind of questions from time to time... it is not that there is a list somewhere of pattern usage for every library... but if you check the javadoc you will find several examples. The most obvious ones have a class finish with something like Singleton, Factory, TO (transfer object)...

From a conceptual point of view the most important patterns in hibernate ...

From a conceptual point of view the most important patterns in hibernate (arguably) would be DAO, DTO, Adapter, AbstractFactory and Singleton... but maybe most if not all of the popular patterns are applied somewhere within the library.

Siva Krishna Gontla · Answer

You are comparing Apples with Oranges.

Spring MVC is about maintaining your code in organized manner.
Example: Controllers only take care of extracting request params., Service classes take care about business logic and Component(DB) classes take care about interacting with database via a ORM framework (or) good old JDBC.

Spring + Hibernate is all about accessing database with the help of a ORM framework so that all the hassles of writing database dependent code with JDBC is gone.

Anonymous · Answer

Spring and Hibernate are two different things, Spring has several components like Dependency Injection, Spring MVC, Spring ORM, Spring Rest API. So Spring ORM and Hibernate are kind of similar, they both deal with the object relation model, which means they deal with connection java objects to data base entities.

Now if you want to build a Rest API using Spring, you can use the Spring Rest API (Here is the getting start guide for Spring Rest Building a RESTful Web Service [ https://spring.io/guides/gs/rest-service/ ]) for ORM you can either choose Hibernate or Spring ORM framework in either cases there are advantages and disadvantages but major industry goes with using Hibernate (I might be wrong!!) I’ve used both of them Spring ORM is quite useful in simple scenarios and Hibernate in some complex scenarios, whereas in most complex scenarios both of them are not quite useful when you want to write really complex queries. (Both of them provide functionalities two write queries by yourself in the case of complex scenarios).

Hope this helps.

I write about technology and on programming related topics. You should follow me if you like the answer and to view any of my future answers.

Ashutosh Dwivedi · Answer

Hibernate - To reduce database dependency on the application. The hibernate is based on ORM .The ORM is used to corelate OOPs based and RDBMS database with JPA library. Thus it uses HQL. We just need to define the database type we wish to use and hibernate will manage the rest. The setting for this is done in cfg.hbm.xml file.

Struts - It is a framework that is used to develop web application using Java .

It uses MVC pattern , where the POJO class contains a predefined method signature like

public String method()

{

Return “Success” ;

}

The POJO class also called action class is read by the struts.xml file in which invokes the method for a particular result return type each for success and error.

And the communication between Java and struts is configured in web.xml file where all latest interceptor as well as filters are set.

Spring- It is a robust web application development framework popularly used these days. Spring is based of Dependency injections (DI).It also uses MVC methodology.

Spring has a very vast usage.

Localazy · Answer

Internationalizing your software expands your audience to other regions/markets, provides you with more visibility and boosts your revenue. In addition, relying on multiple markets adds an extra layer of security and resilience to your business.

Developing multilingual software involves going through three phases: i18n, l10n and t9n.

Internationalization (i18n) is the process of making software localizable — creating or transforming products or services to adapt them to other regions, markets and cultures.

Once the localization (l10n) process is in motion, the next step is translation (t9n).

If you look up localizing Spring MVC (Model-View-Controller) applications, you’ll find detailed tutorials covering setting up beans such as LocaleResolver and LocaleChangeInterceptor to create and set up different locales.

That’s how you can localize apps in a separate environment without your customers noticing or experiencing any changes.

However, going through all those steps manually can be complex, time-consuming and error-prone. That’s where an automated localization platform and web-based translation management system (TMS) like Localazy  [ https://localazy.com/?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ]can prove to be invaluable.

Localazy tackles your MVC app’s localization needs effortlessly. All you have to do is:

1. Add your app to Localazy, regardless of your tech stack. Localazy is equipped to handle 50+ integrations [ https://localazy.com/integrations?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ] and 700+ languages.
2. Install the Localazy CLI for your system and create a configuration file.
3. Upload files with “localazy upload” to translate your project and then pull translated texts back into your project with “localazy download”. You can manage translations on your own or order translations inside the platform and catch up on other development tasks while Localazy handles everything.
https://www.youtube.com/watch?v=q0uEltq02e0&t=10s
We recommend that you release the app (and updates) gradually so that only a small percentage of users will be affected, if you run into some problems.

You should also publish translations without redeploying the app often. Otherwise, debugging and fixing errors won’t be seamless.

With Localazy, you get a powerful, developer-friendly CLI tool and tons of CI/CD options to help you release updates continuously and automatically.

Here are some of the benefits of using Localazy [ https://localazy.com/benefits?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ]:

1. Get machine translations (MT) [ https://localazy.com/dictionary/machine-translation/?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ] to reduce your localization headache.
2. Share translations easily across projects using Connected Projects [ https://localazy.com/docs/general/connected-projects?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ].
3. Use Localazy’s ShareTM [ https://localazy.com/docs/general/what-is-localazy-sharetm/?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ], which is a shared translation memory available for all users.
4. Use the translation editor to translate on your own or invite your team. Also, whenever you make any changes in the source language, Localazy automatically detects them and informs your translators about the texts needing translation.
5. Take advantage of our Continuous Localization services [ https://localazy.com/docs/general/continuous-localization-team/?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ] to sit back and relax while Localazy handles everything.
If you want a hassle-free localization of your Spring MVC apps, give Localazy a try and create a free account [ https://localazy.com/?utm_source=quora&utm_medium=organic&utm_campaign=COLD_ACQ_AWARENESS_QUORA7&utm_term=qanswers ]. We’re sure you’ll find it helpful.

Shahroz Beig · Answer

The way you can explain your project to the interviewer is

1. First of all tell about what you have made in a line.
2. Mention the technologies you have used to develop that project.
3. Explain just about your technical work not about the working and functions of your project which you could have covered in step 1 in a line or two.
4. Explain why you have used MVC, facade, or MVC2 or anything for this project.
5. Explain why only MVC or something that used you have used but not other(if there is any alternative that you could have used to develop that project).
6. While explaining don't sit like a fool and speak like you are reading something, try to explain with good attitude, few hand gestures, and facial expressions.
7. Have a constant slight smile on your face that must not look fake.
8. Have a look at the code properly before the interview, interviewer may ask you to write something from there.
The way you can explain project to your interviewer directly proportional to chances of your selection in an interview. So try sometimes at your place, to your friend, or parents, or anyone and observe yourself and get their review before going to an interview.

Hope I've answered your question.

Thank you

Abhishek Purwar · Answer

First thing is that these are not languages. These are frameworks for developing software applications.

Hibernate - This is an ORM (Object Relation Mapping) framework for data layer of software application. ORM framework helps in converting data into POJO (plain java object) and also provide other capabilities like default SQL operations like insert, delete, read and update, user can also create custom queries, caching of data, etc. This removes dependency between application and data base. It helps in changing database from one type to other without making any changes in POJOs.

Struts - This is web application development framework which works on MVC (Model View Controller pattern). This helps in defining clear boundaries between different tiers of application. This helps in easy maintenance of application.

Spring - This is framework for developing software application. This framework has lot of components which provides different functionalities. Some of components:

Spring Core: This provides dependency injection or IoC.

Spring MVC: This follows MVC pattern for application development.

Spring Transaction Management: This provides transaction management for application.

Spring Data Access Framework: This provides data management functionality.

And there are some other components also.

Anonymous · Answer

Design patterns used in Hibernate

* Domain Model Pattern – An object model of the domain that incorporates both behavior and data.
 * Proxy Pattern for lazy loading.
 * Unit of Work (as part of Session object)
 * Factory Pattern in Session Factory
 * Query Object for Criterion API
 * Data Mapper – A layer of Mappers that moves data between objects and a database while keeping them independent of each other and the mapper itself.
 * Active Record Pattern
 * DAO
 * Object-Relational Mapping(ORM)
 * etc