Architektura trójwarstwowa - potrzebny przykład

Wikipedia ma ładne Wyjaśnienie: Multitier architecture :

' three-tier ' to architektura klient-serwer, w której interfejs użytkownika, funkcjonalna logika procesu ("reguły biznesowe"), komputerowe przechowywanie danych i dostęp do danych są rozwijane i utrzymywane jako niezależne moduły, najczęściej na oddzielnych platformach.

Wykorzystanie Web development

W dziedzinie tworzenia stron internetowych trójwarstwowy jest często używany do strony internetowe, powszechnie internetowe sklepy internetowe, które są budowane przy użyciu trzech warstw:

• front-endowy serwer WWW obsługujący zawartość statyczną i potencjalnie część buforowanej zawartości dynamicznej.
• serwer aplikacji średniego poziomu dynamicznego przetwarzania i generowania treści, na przykład Java EE, ASP.net, Platforma PHP.
• back-endowa baza danych, obejmująca zarówno zbiory danych, jak i system zarządzania bazami danych lub oprogramowanie RDBMS, które zarządza i zapewnia dostęp do dane.

Przez "warstwa" masz na myśli "warstwę" w stosie oprogramowania? Słowo "warstwa" jest lepiej używane do opisu fizycznych komponentów systemu. Jeśli używasz ASP.NET, prawdopodobnie masz już system "3 warstwowy" -

1. przeglądarka wyświetlająca strony www
2. serwer IIS hosting Twojej aplikacji
3. serwer bazy danych z bazą danych

Ale prawdopodobnie umieszczasz cały kod w jednej "warstwie" oprogramowania - w szczególności kod znajdujący się za plikiem twojego aspx stron. Chcesz przejść z jednej warstwy do podejścia 3-warstwowego. Klasyczna" 3-warstwowa " Architektura oprogramowania składa się z następujących elementów -

1. Warstwa Prezentacji

2. Business Logic Layer (BLL)

3. Data Access Layer (DAL)

Alt text http://weblogs.asp.net/blogs/fredriknormen/WindowsLiveWriter/UsingWebServicesina3tierarchitecture_134F6/3tier_2.jpg

Dla typowego ASP.NET aplikacji, możesz zastosować to jako / align = "left" / Najpierw tworzymy plik LINQ2SQL (.dbml) zawierający obiekty dostępu do bazy danych. To jest twoja Warstwa dostępu do danych (DAL).

Następnie możesz utworzyć bibliotekę DLL zawierającą twoją warstwę logiki biznesowej (BLL). Ta warstwa będzie uzyskiwać dostęp do bazy danych za pośrednictwem DAL, manipulować nią w razie potrzeby, a następnie udostępniać ją za pomocą prostego interfejsu. Na przykład, jeśli aplikacja wyświetla listę klientów, BLL może mieć publiczną funkcję o nazwie GetClientList (), która zwróciła lista klientów.

W końcu ustawiłbyś kod za plikami, aby utworzyć instancję BLL i podłączyć go do komponentów interfejsu. To jest twoja warstwa prezentacji. Na przykład, może pobrać dane zwrócone z funkcji GetClientList() i powiązać je z siatką danych w formularzu internetowym. Chodzi o to, aby warstwa prezentacji była jak najcieńsza.

To wydaje się trochę za długie do opisania, ale jest dość proste, gdy już to zrobisz kilka razy. Przekonasz się, że oddzielenie aplikacji w ten sposób znacznie ułatwi jej utrzymanie, ponieważ oddzielenie obaw prowadzi do czystszego kodu. Znacznie łatwiej jest również uaktualnić lub nawet wymienić warstwę prezentacji, ponieważ zawiera ona bardzo mało sprytu. Wreszcie, dojdziesz do punktu, w którym masz wiele bardzo przydatnych bibliotek BLL, które można łatwo wykorzystać w nowych aplikacjach, znacznie poprawiając produktywność.

Warstwa prezentacji : Umieść wszystko, co jest związane z interfejsem użytkownika. (Co widzi użytkownik)

Warstwa Biznesowa : wszystko, co jest związane z logiką aplikacji (jak traktowane są informacje pochodzące z warstwy prezentacji)

Warstwa danych : Podaj abstrakcję bazowych źródeł danych (gdzie i w jaki sposób przechowywane są informacje pochodzące z/przechodzące do warstwy biznesowej)

Każda warstwa powinna wiedzieć jak najmniej o inne i powinno to być podejście odgórne:

• Warstwa danych nie powinna nic wiedzieć o biznesie i prezentacji
• warstwa biznesowa powinna wiedzieć o danych, ale nie o prezentacji
• prezentacja powinna wiedzieć o biznesie, ale nie o danych

Prosty przykład:

Strona WWW:

• Prezentacja: wszystkie elementy graficzne, pola, w których użytkownik wstawia dane, Menu, zdjęcia itp.
• biznes: wszystkie ograniczenia dotyczące danych (unikalna nazwa, Nazwa bez symboli, poprawna data, itp.), metody manipulowania obiektami biznesowymi (tworzenie nowego użytkownika, Dodawanie nowego porządku, itp.)
• Data: metody, które uzyskują dostęp do baz danych.

Architektura trójwarstwowa może mieć różne znaczenia w zależności od kontekstu. Zasadniczo oznacza to, że obowiązki w aplikacji są podzielone na różne poziomy. Typowo 3-warstwowe odnosi się do:

• warstwa prezentacji " (rzeczywisty interfejs użytkownika)
• warstwa logiczna (logika aplikacji/biznesowa)
Data tier (baza danych, przechowywanie danych)

Szczegóły różnią się w zależności od zastosowania.

Wikipedia, jak zwykle, ma ładny przegląd: http://en.wikipedia.org/wiki/Multitier_architecture

Prostym przykładem może być typowa aplikacja biznesowa:

• presentation: browser, or fat client
• warstwa logiczna: logika biznesowa, zazwyczaj w serwerze aplikacji (oparta na J2EE, ASP.NET lub cokolwiek)
W zależności od tego, czy jest to baza danych, czy RDBMS, jest to Warstwa danych.]}

Trójwarstwowa Architektura zazwyczaj składa się z następujących elementów:

1. Client Browser
2. serwer WWW hosting the ASP.NET zastosowanie
3. Niektóre backend storage, takie jak baza danych, która jest dostępna przez ASP.NET zastosowanie

Więc aby odpowiedzieć na twoje pytanie Jak napisać kod dla architektury 3-warstwowej, rozwijasz ASP.NET aplikacja komunikująca się z magazynem danych.

Dobry tutorial, z pełną kontrolą źródła Pobierz dobrze napisaną aplikację warstwową będzie tutaj:

Http://nerddinnerbook.s3.amazonaws.com/Intro.htm

To nie jest samouczek o architekturze warstwowej, ale jest to dobrze napisana aplikacja i daje pewien wgląd w to, dlaczego można rozważyć tę architekturę.

DODATKOWO, jak zostało tylko krótko poruszone powyżej, chodzi o utrzymanie kodu logiki/pamięci / prezentacji oddzielnie, więc jeśli musisz zmienić jeden z nich (np. zmiana z asp.net front end do aplikacji desktopowej), nie jest to takie trudne do zrobienia.

Three-tier (warstwa) to architektura klient-serwer, w której interfejs użytkownika, proces biznesowy (reguły biznesowe) oraz przechowywanie danych i dostęp do danych są rozwijane i utrzymywane jako niezależne moduły lub najczęściej na oddzielnych platformach.

Zasadniczo są 3 warstwy:

• tier 1 (tier prezentacji, tier GUI)
Tier 2 (business objects, business logic tier)
• warstwa 3 (warstwa dostępu do danych). Poziomy te można rozwijać i testować osobno.

Jaka jest potrzeba dzielenia kodu na 3 poziomy? Oddzielenie interfejsu użytkownika od logiki biznesowej i dostępu do bazy danych ma wiele zalet. Niektóre z zalet są następujące:

Wielokrotne użycie komponentu logiki biznesowej skutkuje szybkim rozwój. Załóżmy, że mamy moduł, który obsługuje dodawanie, aktualizowanie, usuwanie i znajdowanie klientów w systemie. Ponieważ ten składnik jest opracowany i przetestowany, możemy go wykorzystać w każdym innym projekcie to może angażować w utrzymanie klientów.

Transformacja systemu jest łatwa. Ponieważ logika biznesowa jest oddzielenie warstwy dostępu do danych, Zmiana warstwy dostępu do danych nie wpłynie to zbytnio na moduł logiki biznesowej. Powiedzmy, że jeśli jesteśmy przejście z SQL Server data storage do Oracle nie powinno być żadnych wymagane zmiany w komponencie warstwy biznesowej i GUI komponent.

Zarządzanie zmianami w systemie jest proste. Powiedzmy, że jeśli istnieje małoletni zmiany w logice biznesowej, nie musimy instalować całego system w komputerach indywidualnych użytkowników. Np. jeżeli GST (podatek) zostanie zmieniony z 10% do 15% wystarczy tylko zaktualizować komponent logiki biznesowej bez wpływające na użytkowników i bez przestojów.

Posiadanie odrębnych serwerów funkcjonalnych pozwala na równoległy rozwój poszczególnych warstw przez specjalistów aplikacji.

Zapewnia bardziej elastyczną alokację zasobów. Może zmniejszyć sieć ruchu poprzez posiadanie funkcjonalność serwery pasują do dokładnych danych struktura potrzebna przed wysłaniem jej do klientów.

connection class
-----------------------

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Web .UI.WebControls ;
/// <summary>
/// Summary description for conn
/// </summary>
namespace apm_conn
{
    public class conn
    {
        public SqlConnection getcon()
        {
            SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["connect"].ConnectionString );
            if (con.State == ConnectionState.Closed)
            {
                con.Open();
            }
            return con;
        }
        #region execute command
        public string  Executecommand(SqlParameter []sqlparm,string sp)
        {
            string r_val = "";
            try
            {

                SqlConnection con = new SqlConnection();
                con = getcon();
                SqlCommand cmd = new SqlCommand();
                cmd.Connection = con;
                cmd.CommandText = sp;
                cmd.CommandType = CommandType.StoredProcedure;
                foreach (SqlParameter loopvar_parm in sqlparm)
                {
                    cmd.Parameters.Add(loopvar_parm);

                }
                cmd.Parameters.Add("@Var_Output", SqlDbType.VarChar, 20).Direction = ParameterDirection.Output;
                cmd.ExecuteNonQuery();
                r_val = (string)cmd.Parameters["@Var_Output"].Value;
                con.Close();
            }
            catch { }
            return r_val;

        }

        #endregion
        #region Execute Dataset
         public DataSet ExeccuteDataset(SqlParameter[] sqlParm, string sp)
    {
        DataSet ds = new DataSet();
        try
        {
            SqlConnection con = new SqlConnection();
            con = getConn();
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = con;
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.CommandText = sp;
            foreach (SqlParameter LoopVar_param in sqlParm)
            {
                cmd.Parameters.Add(LoopVar_param);
            }
            cmd.ExecuteNonQuery();
            SqlDataAdapter da = new SqlDataAdapter(cmd);
            da.Fill(ds);

        }
        catch
        { }
        return ds;
    }
        #endregion
        #region grid
        public void Bindgrid(DataSet ds,GridView g)
        {
            try
            {
                g.DataSource = ds.Tables[0];
                g.DataBind();

            }
            catch { }
        }
        #endregion
        #region Dropdownlist
        public void Binddropdown(DropDownList dl,DataSet ds,string text,string value)
        {
            try
            {
                dl.DataSource = ds.Tables[0];
                dl.DataTextField = text;
                dl.DataValueField = value;
                dl.DataBind();
            }
            catch
            {}

        }
        #endregion
        public conn()
        {
            //
            // TODO: Add constructor logic here
            //
        }
    }
}




dal
---------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using apm_conn;
using System.Data.SqlClient;
using apm_ent;

/// <summary>
/// Summary description for Class1
/// </summary>
namespace apm_dal
{
    public class dal
    {
        conn ob_conn = new conn();
        public dal()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        public string insert(ent obj_ent)
        {
            SqlParameter[] sqlparm =
        {
            new SqlParameter ("@Var_Action",obj_ent.Var_Action),
            new SqlParameter ("@Int_Id",obj_ent.Int_Id ),
             new SqlParameter ("@Var_Product",obj_ent.Var_Product ),
              new SqlParameter ("@Dc_Price",obj_ent.Var_Price ),
              new SqlParameter ("@Int_Stat",obj_ent.Int_Stat ),

                               };
            return ob_conn.Executecommand(sqlparm, "Proc_product");
        }
        public string ins(ent obj_ent)
        {
            SqlParameter[] parm =
        {
            new SqlParameter ("@Var_Action",obj_ent .Var_Action),
            new SqlParameter ("@Int_Id",obj_ent .Int_Id),
                            };
            return ob_conn.Executecommand(parm, "Proc_product");
        }
    }

}

bal
-------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using apm_ent;
using apm_dal;

/// <summary>
/// Summary description for bal
/// </summary>
namespace apm_Bal
{

    public class bal
    {
        dal ob_dal = new dal();
        string r_val = "";
        public bal()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        public string insert(ent obj_ent)
        {
            return ob_dal.insert(obj_ent);
        }
    }
}



Ent
------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

/// <summary>
/// Summary description for ent
/// </summary>
namespace apm_ent
{
    public class ent
    {
        public ent()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        #region Ent
        public int Int_Id { get; set; }
        public string  Var_Action { get; set; }
        public string Var_Product { get; set; }
        public decimal  Var_Price { get; set; }
        public int Int_Stat { get; set; }
        #endregion
    }
}



page code
--------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using apm_conn;
using apm_ent;
using apm_Bal;
using apm_conn;
public partial class _Default : System.Web.UI.Page
{
    conn obj_conn = new conn();
    ent obj_ent = new ent();
    bal obj_bal = new bal();
    string r_val = "";
    protected void Page_Load(object sender, EventArgs e)
    {

    }
    protected void btnsub_Click(object sender, EventArgs e)
    {
        obj_ent.Var_Action = "INS";
        obj_ent.Var_Product = txtproduct.Text;
        obj_ent.Var_Price = Convert.ToDecimal (txtprice.Text);
        r_val = obj_bal.insert(obj_ent);
        if (r_val == "1")
        {
            Response.Write("<script>alert('Inserted Sucessfully')</script>");
        }
    }
}