Explication graphique détaillée de l'architecture Python à trois niveaux

Cet article explique en détail avec des images et du textepythonArchitecture à trois niveaux

Architecture à trois niveaux (3 -architecture à trois niveaux) Habituellement, l'architecture à trois niveaux dans le sens consiste à diviser l'ensemble de l' application métier en :
Couche de présentation (Couche de présentation), couche de logique métier (Business Logic Couche), couche d'accès aux données (Couche d'accès aux données).

Le but de la distinction des niveaux est l'idée de "forte cohésion et faible couplage".
Une cohésion élevée et un faible couplage sont un concept en génie logiciel et un critère pour juger si une conception est bonne ou mauvaise. Il s'agit principalement de conception orientée objet et dépend principalement de. la cohésion des classes. Si le sexe est élevé et le degré de couplage est faible.
La cohésion est la façon dont les éléments d'un module sont combinés les uns avec les autres. La cohésion élevée est la façon dont les éléments d'un module sont combinés les uns avec les autres.

La soi-disant cohésion élevée signifie qu'un module logiciel est composé de codes hautement liés et n'est responsable que d'une seule tâche, souvent appelée principe de responsabilité unique.
Couplage : mesure du degré d'interconnexion entre différents modules au sein d'une structure logicielle (le couplage est également appelé connexion inter-blocs. Il fait référence à une mesure de l'étroitesse de l'interconnexion entre les modules dans un structure du système logiciel.
Plus la connexion entre les modules est étroite, plus le couplage est fort et plus l'indépendance du module est mauvaise. Le niveau de couplage entre les modules dépend de la complexité de l'interface. entre les modules, la méthode d'appel et les informations transmises)
Pour un faible couplage, une compréhension approximative est :
Un système complet, dans la mesure du possible entre les modules pour le faire exister indépendamment.
En d'autres termes, laissez chaque module remplir une sous-fonction spécifique de la manière la plus indépendante possible.
Les interfaces entre les modules doivent être aussi peu nombreuses et simples que possible.
Si la relation entre deux modules est relativement complexe, il est préférable d'envisager d'abord une division plus approfondie des modules.
C'est pratique pour la modification et la combinaison.

Architecture à trois niveaux, comme indiqué ci-dessous :

1. Couche de présentation (UI) : En termes simples, il s'agit de l'interface affichée à l'utilisateur, c'est-à-dire ce que l'utilisateur voit et gagne lorsqu'il utilise un système.
2. Couche de logique métier (BLL) : les opérations pour des problèmes spécifiques peuvent également être considérées comme des opérations sur la couche de données et le traitement logique des données.
3. Couche d'accès aux données (DAL) : Les transactions effectuées par cette couche exploitent directement la base de données, pour ajouter, supprimer , modifier, rechercher, etc.

Exemple :

#coding:utf8

from utility.sql_helper import MySqlHelper

class Admin(object):
    def init(self):
        self.helper = MySqlHelper()
        
    def Get_One(self,id):
        sql = "select * from userinfo where id = %s"
        params = (id,)
        return self.helper.Get_One(sql, params)
    
    def CheckValidate(self,username,password):
        sql = "select * from userinfo where name=%s and password=%s"
        params = (username,password,)
        return self.helper.Get_One(sql, params)

#coding:utf8
import MySQLdb
import conf


class MySqlHelper(object):
    def init(self):
        self.conn_dict = conf.conn_dict
    def Get_Dict(self,sql,params):
        conn = MySQLdb.connect(**self.conn_dict)
        cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor) 
        
        reCount = cur.execute(sql,params)
        data = cur.fetchall()   

        cur.close()
        conn.close()
        return data
       
    def Get_One(self,sql,params):
        conn = MySQLdb.connect(**self.conn_dict)
        cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor) 
        
        reCount = cur.execute(sql,params)
        data = cur.fetchone()  

        cur.close()
        conn.close()
        return data

#coding:utf8

conn_dict = dict(
    host='127.0.0.1',
    user='root',
    passwd='123456',
    db ='Admin'
    )

#coding:utf8

from module.admin import Admin

def main():
    user=raw_input('username:')
    pwd=raw_input("password:")
    admin = Admin()
    result = admin.CheckValidate(user, pwd)
    if not result:
        print '用户名或密码错误'
    else:
        print '进入后台登录界面'

if name== 'main':
    main()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!