Enterprise application architecture
1 / 33

Enterprise Application Architecture - PowerPoint PPT Presentation

  • Uploaded on

Enterprise Application Architecture. Divide a complex system into layers e.g. TCP, IP, Ethernet, physical layer 2- layers 1990s, Client-server, 2 layers Presentation + Database 3- layers (or 3-tiers) structure An expanded domain logic layer Presentation, Domain Logic and Database.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' Enterprise Application Architecture' - rey

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Enterprise application architecture
Enterprise Application Architecture

  • Divide a complex system into layers

    • e.g. TCP, IP, Ethernet, physical layer

  • 2- layers

    • 1990s, Client-server, 2 layers

    • Presentation + Database

  • 3- layers (or 3-tiers) structure

    • An expanded domain logic layer

    • Presentation, Domain Logic and Database

Presentation layer
Presentation Layer

  • Template View

    • The simplest way

    • Generate a HTML page dynamically by embedding markers into a static HTML page

    • Using languages like JSP, ASP, or PHP

  • MVC model

    • For more complex systems

Service layer
Service Layer

  • Add a service layer to define application’s boundary

    • So as to support different interfaces (GUI, web, …)

    • e.g. use a Façade object to connect to a GUI client


Service Layer

Domain Model



One common way of handling complicated applications
One common way of handling complicated applications

  • Front Controller

    • A controller that handles all requests

    • Delegate the work to a command object

Big problem domain model to database mismatch
Big problem - domain model to database mismatch

  • Data is typically stored in the form of tables in relational database

  • Fundamental differences between OO model and relational model

    • Relational model has no concept of inheritance

    • Tables in relational model are related by keys, classes in OO model are related by references

      • Keys must be explicit (need a field to contain) while references can be implicit

  • The impedance mismatch problem

    • Difficult to map an object to a table directly

Inheritance problem
Inheritance problem

  • How to store the object hierarchy to a relational database?








Object to table mapping problem
Object to table mapping problem

  • Table per class

    • Map each class to a table

  • Table per Concrete Object

    • Map each concrete object to a table

  • Single table for the entire class family

    • Map everything into a single table

  • None of them is satisfactory

Map each class to a table
Map each class to a table

  • Pros

    • Classes can be modified independently

  • Cons

    • To rebuild an object, need to join the data from multiple tables

    • Tables are related by keys, keeping track of the key can be complex







Map each concrete object to a table
Map each concrete object to a table

  • Pros

    • Simple

  • Cons

    • If a field in the superclass is changed, then all subclasses’ tables have to be changed too

    • Redundancy between tables, which may lead to inconsistencies

      • Defeat the purpose of normalization










Single table inheritance
Single Table Inheritance

  • Merge all fields in all classes into one table

  • Advantages

    • Simple, changes can be done in one table

  • Disadvantage

    • Large number of null columns, waste storage

    • Defeat the purpose of normalization

Type title format region

aLendable A111 -- --

aDVD Casablanca Color 3

Identity problem
Identity problem

  • Two objects can have EXACTLY the same states, but still they have different identity

  • The identity of objects come naturally as they are referenced by different pointers

    • Often you don’t need a special field to store the identity

  • e.g. A Borrower has-a collection of Books

    • Borrower knows Book via the reference but not the other way round (Book does not know the Borrower)

Tables for borrower and book
Tables for Borrower and Book

Borrower table

Book table

Identity problem1
Identity problem

  • In RDBMS, Book needs to know the Borrower (the opposite of OO model)

    • To write the Books back to database, Book needs identify the borrower uniquely by the BorrowerID

      • The primary key in Borrower table

      • The foreign key in Book table

  • O/R (object to relational) mapping

    • Need to add an extra attribute in the Book object for the foreign key

    • This field is called Identify Field

Foreign key mapping
Foreign key mapping

  • This is not enough

    • class Book …

      string title;


  • An extra attribute to store the key for the database

    • class Book …

      string title;

      string BorrowerID; //foreign key field


O r mapping orm tool
O/R mapping (ORM) tool

  • To bridge the gap between OO model and relational database automatically

    • e.g. Hibernate for Java and NHibernate for .NET

    • Translating objects to forms which can be stored in the database

    • Ideal case, the object model sees no SQL, and the underlying relational database

      • Developers see a virtual objects store

    • One of the most active research areas in computer science

Limitations of o r mapping
Limitations of O/R Mapping

  • Object to Table mapping problem, as mentioned before

  • Automatic translation from objects to SQL efficiently is hard

    • O/R mapping tools may solve 80% of the problems, they therefore also offer OQL (object query language) to take care of difficult cases

  • Efforts in program the database schema into the ORM

So what can we do about this impedance mismatch
So what can we do about this impedance mismatch?

  • Ted Neward listed 6 solutions in the following site

    • http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.aspx

    • Acceptance of O/R-M limitations – use automated O/R mapping tools

    • Wholehearted acceptance – used OODBMS

    • Abandonment – give up OO completely

    • Integration of relational concepts into frameworks

    • Manual mapping – constructs object using manually coded SQL

    • Integration of relational concepts into the languages – e.g. LINQ in C# 3.0

Oodbms oo database management system
OODBMS (OO Database Management System)

  • Bypass the O/R mapping problem, object is stored as it is, not in the form of table

    • e.g. db4o (db for objects)

  • Can search and retrieve objects directly, no need to join tables

    • Very fast, high performance

  • But OODBMS is almost dead in commercial applications

    • Why?

Problem with oodbms
Problem with OODBMS

  • Database is shared by many departments in a company

  • Different department views/uses the database differently

  • Data in OODBMS is designed for a particular object model, i.e., a particular view point

    • Tight coupling between database schema and the developer’s model is a bad thing, other department may view the structure of the data in different way

Problem with oodbms1
Problem with OODBMS

  • RDBMS concerns only about storing the data efficiently via normalization, without regard to any particular object model (neutral to any application), therefore is an advantage

  • Nevertheless, OODBMS holds the record for the largest database (Stanford Linear Accelerator Centre – 1 Petabyte)


  • Abandonment

    • Based completely on relational model

    • No objects, therefore no impedance mismatch

  • Most applications have a lot to do with CRUD (create, read, update, delete)

    • RDBMS + transaction script (for business logic)

  • Transaction script

    • e.g. PHP, ASP, JSP, CGI

    • A single procedure for each user initiated action

Transaction script
Transaction script

  • Disadvantage

    • No separation between presentation and business logic layers

    • Changes in database or business logic will affect many scripts

    • Suitable for simple applications only

Integration of relational concepts into frameworks
Integration of relational concepts into frameworks

  • Using objects that is more relational in nature

    • e.g. Recordset in ADO.NET and JDBC

    • Recordset is like a table from SQL query (View)

  • Advantages

    • Can be processed offline from the database

    • UI can be updated directly

      • Platform supports smart data-aware GUI updating

  • Disadvantages

    • Tight coupling between database schema and the GUI

    • Suitable only for CRUD applications

Manual mapping
Manual mapping

  • Solve the problem by writing SQL to access the tables, returning the objects

    • But too much code to write and maintain

  • E.g. Row Data Gateway

    • Each gateway object represents a row in the database table and has methods that encapsulate the SQL

    • class BorrowerGateway … {

      Borrower find(borrowerID) {…}


    • find() encapsulates the SQLs and return a Borrower object

  • Table Data Gateway

    • To get the booklist for Borrower using Row Data Gateway takes multiple database read

    • Table Data Gateway is an object that reads multiple records and returns a table in one go

    • More efficient

Data mapper
Data Mapper

  • For more complex situation

    • A direct mapping between database record and domain object may not be possible

    • Need to add an layer to carry out the mapping

    • Data Mapper = an intermediate object that maps between domain object and the relational database

Integration of relational concepts into the languages
Integration of relational concepts into the languages

  • Call-Level Interfaces (CLI)


    • CLI provides an object-like API by passing a SQL query as a string literal into the library, and returning the result of the query

  • Problems

    • Verbosity

    • SQL code scattered across the application, difficult to change the database schema in a manner independent of the object model

    • OK for smaller projects, but for large systems, need to add comment tags to the SQL in the code so that they can be located more easily

Integration of relational concepts into the languages1
Integration of relational concepts into the languages

  • Recent approach

  • Integrate query language directly into traditional O-O languages

  • e.g. LINQ project for C# and Visual Basic

  • LINQ (Language INtegrated Query)

    • Can query anything that has structure

      • Data in a container

      • RDBMS

      • XML

    • The main feature in C# 3.0


  • A unified language for making query to different structures using C#-like syntax

  • Compiler turns LINQ’s statements into an Abstract Syntax Tree (see Interpreter pattern)

    • The tree is translated into specific queries by various add-on programs, e.g.

    • LINQ for SQL (previously DLINK) – for RDBMS

    • XLINQ – for XML data










  • Since LINQ is part of the language (C# ver3.0), the syntax of the query language can be checked during compile time and not during run time

    • Strings embedded in CLI calls cannot be checked by compiler

  • Strong type checking can be performed by the compiler, which cannot be done by O/R mappers as they have no control on the C# compilers

  • LINQ does not deal with O/R mapping, it is only an extension to the compiler

    • LINQ to SQL generates the SQL code, and is therefore a kind of O/R mapper

    • Differentiation between O/R mappers in the future will be based on how well they implement the translation from LINQ to SQL

Example define the class to table mapping
Example: define the class to table mapping


public class Borrower { [Column(DbType="nvarchar(32) not null",Id=true)]

public string Name;


public int BorrowerID;



public class Book {

[Column(DbType="nvarchar(32) not null", Id=true)] public string Title;


public int BorrowerID;


public int BookID;


A list of borrowers and the borrowed books
A list of borrowers and the borrowed books

// establish a query context connection to ADO.NET

DataContext context = new DataContext( connectionString );

// grab variables that in the remote tables

Table<Borrower> user = context.GetTable<Borrower>();

Table<Book> books = context.GetTable<Book>();

// build the query, query is anonymous class

var query = from u in user, b in books where u.BorrowerID == b.BorrowerID

select new { u.Name, b.Title };

// execute the query foreach (var item in query) Console.WriteLine("{0} {1}", item.Name, item.Title);


  • The LINQ Project – Don Box and Anders Hejlsberg

    • http://msdn2.microsoft.com/en-us/library/aa479865.aspx

  • Comparing LINQ and Its Contemporaries – Ted Neward

    • http://msdn2.microsoft.com/en-us/library/aa479863.aspx