le mie informazioni di contatto
Posta[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Proxy Pattern è un modello di progettazione strutturale che controlla l'accesso a un altro oggetto introducendo un oggetto proxy. Questo oggetto proxy può fornire funzionalità aggiuntive all'oggetto proxy, ad esempio controllo dell'accesso, inizializzazione lenta, registrazione o accesso alla rete.
agente remoto:
agente virtuale:
agente di protezione:
Guida intelligente:
Di seguito è riportato un semplice esempio di implementazione del modello proxy, che mostra come controllare l'accesso a un oggetto reale tramite un oggetto proxy.
public interface Subject {
void request();
}
Subject
L'interfaccia definisce arequest
Metodo, questo è il metodo che sia l'oggetto reale che l'oggetto proxy devono implementare.public class RealSubject implements Subject {
public void request() {
System.out.println("RealSubject: Handling request.");
}
}
RealSubject
classe implementataSubject
Interfacciarequest
Metodo, che rappresenta la classe che gestisce effettivamente la richiesta.public class Proxy implements Subject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
public void request() {
if (this.checkAccess()) {
this.realSubject.request();
this.logAccess();
}
}
private boolean checkAccess() {
// 检查访问权限
System.out.println("Proxy: Checking access prior to firing a real request.");
return true;
}
private void logAccess() {
// 记录请求日志
System.out.println("Proxy: Logging the time of request.");
}
}
Proxy
classe implementataSubject
interfaccia e contiene aRealSubject
oggetto.request
Nel metodo, la classe proxy controlla prima i permessi di accesso e poi chiama l'oggetto realerequest
metodo e infine registrare il registro della richiesta.public class Client {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
Proxy proxy = new Proxy(realSubject);
proxy.request();
}
}
Client
classe creataRealSubject
EProxy
oggetto, attraversoProxy
Chiamata oggettorequest
metodo per controllare ilRealSubject
Accesso.Isolamento:
sicurezza:
Scalabilità:
Intelligente:
complessità del codice:
Tempo di risposta:
Difficoltà di progettazione:
Client
|
v
Subject <---- Proxy <---- RealSubject
Il modello proxy fornisce un modo efficiente per controllare e gestire l'accesso agli oggetti. Utilizzando i proxy, è possibile aggiungere varie funzioni mantenendo chiare le responsabilità degli oggetti business. Questa modalità è particolarmente adatta per scenari che richiedono il controllo degli accessi e altre operazioni di preelaborazione sugli oggetti business.
Facade Pattern è un modello di progettazione strutturale che semplifica l'utilizzo di sottosistemi complessi fornendo un'interfaccia unificata per l'accesso a un gruppo di interfacce nel sottosistema. Il modello della facciata definisce un'interfaccia di alto livello che rende questo sottosistema più facile da usare.
Semplificare le interfacce per sistemi complessi:
Gerarchia:
Sistema disaccoppiato:
Quello che segue è un semplice esempio di implementazione del modello Facade, che mostra come semplificare l'uso dei sottosistemi attraverso le classi di facciata.
public class SubsystemA {
public void operationA() {
System.out.println("SubsystemA: operationA");
}
}
public class SubsystemB {
public void operationB() {
System.out.println("SubsystemB: operationB");
}
}
public class SubsystemC {
public void operationC() {
System.out.println("SubsystemC: operationC");
}
}
public class Facade {
private SubsystemA subsystemA;
private SubsystemB subsystemB;
private SubsystemC subsystemC;
public Facade() {
this.subsystemA = new SubsystemA();
this.subsystemB = new SubsystemB();
this.subsystemC = new SubsystemC();
}
public void operation1() {
System.out.println("Facade: operation1");
subsystemA.operationA();
subsystemB.operationB();
}
public void operation2() {
System.out.println("Facade: operation2");
subsystemB.operationB();
subsystemC.operationC();
}
}
public class Client {
public static void main(String[] args) {
Facade facade = new Facade();
facade.operation1();
facade.operation2();
}
}
Classe del sottosistema:
SubsystemA
, SubsystemB
, E SubsystemC
È la classe di implementazione specifica del sottosistema e ciascuna classe ha il proprio metodo operativo univoco.Classe di aspetto:
Facade
Le classi contengono oggetti del sottosistema e forniscono interfacce semplificateoperation1
Eoperation2
per chiamare le funzioni del sottosistema.codice cliente:
Client
lezione superataFacade
lezione da chiamareoperation1
Eoperation2
, semplificando così l'utilizzo di sottosistemi complessi.Interfaccia semplificata:
accoppiamento lasco:
migliore stratificazione:
Non rispetta il principio apri-chiudi:
Potrebbe causare problemi di prestazioni:
Client
|
v
Facade ----> SubsystemA
----> SubsystemB
----> SubsystemC
Il modello Facade semplifica il lavoro con sottosistemi complessi fornendo un'interfaccia semplificata. È adatto per scenari in cui è necessario semplificare l'interfaccia del sottosistema, ridurre l'interazione diretta tra il client e il sottosistema e disaccoppiare la gerarchia del sistema. Sebbene possa potenzialmente violare il principio aperto-chiuso, nella maggior parte dei casi i suoi vantaggi superano di gran lunga gli svantaggi, rendendo la progettazione del sistema più chiara e più facile da mantenere.