Im vorherigen Abschnitt "Die erste Schlacht von SSH Framework Online Mall Project: Integration of Struts2, Hibernate4.3 und Spring4.2" haben wir die Entwicklungsumgebung für Struts2, Hibernate und Frühling aufgebaut und erfolgreich integriert. In diesem Abschnitt wird hauptsächlich einige grundlegende Ergänzungen, Löschungen, Änderungen und Suche sowie die Extraktion von Dienst, DAO und Aktion abgeschlossen.
1. Extraktion der Serviceschicht
Im vorherigen Abschnitt haben wir einfach die Speicher- und Aktualisierungsmethoden in der Serviceschicht geschrieben. Hier verbessern wir den Code in diesem Teil und extrahieren dann den Code in der Serviceschicht.
1.1 Verbesserung der Kategorieserviceschicht
Der Betrieb der Datenbank ist nichts anderes als hinzuzufügen, zu löschen, zu ändern und zu überprüfen. Lassen Sie uns zunächst die Schnittstelle und Implementierung der Kategorieservice -Schicht verbessern:
// CategoryService Interface Public Interface CategoryService erweitert BaseSeService <kategorie> {public void Save (Kategorie Kategorie); // öffentliche void -Update einfügen (Kategorie Kategorie); // öffentliche void delete (int id) aktualisieren; // öffentliche Kategorie Get (int id) löschen; // Erhalten Sie eine Kategorie Public List <Kategorie> query (); // Alle Kategorien erhalten} Spezifische Implementierung der Kategorieservice -Schnittstelle:
öffentliche Klasse CategoryServiceImpl erweitert BaseSeServiceImpl <kategorie> implementiert categoryService {private sessions -SessionFactory; // Spring injizieren öffentliche void setSessionFactory (SessionFactory SessionFactory) {this.SessionFactory = sessionFactory; } Protected Session getSession () {// Erstellen Sie die Sitzung aus dem aktuellen Thread, wenn nicht, eine neue Sitzungsrückgabe -Sitzungs -Sitzung. } @Override public void Save (Kategorie Kategorie) {getSession (). Save (Kategorie); } @Override public void update (Kategorie Kategorie) {getSession (). Update (Kategorie); } @Override public void delete (int id) { /*Die erste Methode hat einen Nachteil, das heißt, Sie müssen sie einmal abfragen, bevor Sie es löschen. Objekt obj = getSession (). Get (category.class, id); if (obj! = null) {getSession (). Delete (obj); }*/ String hql = "Kategorie löschen, während id =: id"; GetSession (). CreateEquery (HQL) //setInteger ("id", id) // .executeUpdate (); } @Override öffentliche Kategorie get (int id) {return (category) getSession (). Get (category.class, id); } @Override publiclist <category> query () {string hql = "aus der Kategorie"; return getSession (). CreateEquery (HQL) .List (); }} 1.2 Implementierung von Service Layer Extraktion
Nach Abschluss des CategoryService extrahieren wir die grundlegende Implementierung der Serviceschicht. Die Idee lautet wie folgt: Wir extrahieren einen Basis -Grenzflächen -BaseService und den BaseServiceImpl. Wenn Sie sich später entwickeln, müssen Sie nur zwei Schritte ausführen, wenn ein neuer Dienst benötigt wird: Definieren Sie zunächst eine neue Schnittstelle XXXXService die Basserservice -Schnittstelle, die dieser Schnittstelle neue abstrakte Methoden hinzufügen kann. Definieren Sie dann eine neue Implementierungsklasse xxxServiceImpl erbt BaseServiceImpl und implementiert die XXXXService -Schnittstelle. Dies erleichtert es, das Projekt aufrechtzuerhalten.
Erstellen wir zunächst die BaseSeService -Schnittstelle basierend auf der obigen Kategorieservice -Schnittstelle:
// grundlegende Schnittstellenbassereisen, verwenden Sie den generischen öffentlichen Schnittstellenbasserservice <T> {public void Save (t t); Public void Update (T T); public void delete (int id); öffentlich nicht (int id); öffentliche Liste <T> query (); } Erstellen Sie dann die BaseSeService -Schnittstelle Implementierungsklasse BaseServiceImpl gemäß der CategoryServiceImpl -Implementierungsklasse:
/ ** * @Description todo (Extraktion öffentlicher Module) * @Author Eson_15 * */ @Suppresswarnings ("Deaktiviert") öffentliche Klasse BaseSeServiceImpl <T> Implementiert BaseService <T> {private class clazz; // Der Typ des aktuellen Vorgangs wird im Clazz gespeichert, dh der generische private Sitzungsveranstaltungs -SessionFactory; public baseSeServiceImpl () {// Die folgenden drei Druckinformationen können entfernt werden. Hier ist das System.out.println ("Dies repräsentiert das Objekt, das derzeit den Konstruktor nennt" + dies); System.out.println ("Holen Sie sich die übergeordneten Klasseninformationen des aktuellen dieses Objekts" + this.getClass (). GetuperClass ()); System.out.println ("Holen Sie sich die übergeordneten Klasseninformationen des aktuellen dieses Objekt (einschließlich generischer Informationen)" + this.getClass (). GetGenericsuperClass ()); // den Parametertyp des generischen parameterizierten Typen Type = (parameterizedType) this.getClass (). GetGenericsuperClass (); clazz = (class) type.getActualtTypeargumente () [0]; } public void setSessionFactory (SessionFactory SessionFactory) {this.SessionFactory = sessionFactory; } Protected Session getSession () {// Erstellen Sie die Sitzung aus dem aktuellen Thread, wenn nicht, eine neue Sitzungsrückgabe -Sitzungs -Sitzung. } @Override public void save (t t) {getSession (). Save (t); } @Override public void update (t t) {getSession (). Update (t); } @Override public void delete (int id) {system.out.println (clazz.getSimpename ()); String hql = "delete" + clazz.getSimplename () + "als c wobei c.id =: id"; GetSession (). CreateEquery (HQL) //setInteger ("id", id) // .executeUpdate (); } @Override public t get (int id) {return (t) getSession (). Get (clazz, id); } @Override public list <T> query () {string hql = "from" + clazz.getSimpename (); return getSession (). CreateEquery (HQL) .List (); }} Nach Abschluss der Extraktion können wir die CategoryService -Schnittstelle und die CategoryServiceImpl -Implementierungsklasse neu schreiben. wie folgt:
// CategoryService -Schnittstelle erbt die BaseService -Schnittstelle öffentliche Schnittstelle CategoryService erweitert BaseSeService <kategorie> { / * * Fügen Sie einfach die neue Methode hinzu, die von CategoryService selbst erforderlich ist. Die öffentliche Methode befindet sich bereits in BaseSeService * /} / ** * @Description Todo (die Geschäftslogik des Moduls selbst) * @Author Eson_15 * * / öffentliche Klassenkategorie -Service erweitert BaseServiceImpl <category> implements categoryService { / * * Implementieren Sie die neu hinzugefügte Methode in der Kategorie. Die öffentliche Methode wurde in BaseSeServiceImpl */} implementiert Wie aus dem Code ersichtlich ist, muss der neu hinzugefügte Dienst nur die BasSeSeService -Schnittstelle erben und dann die vom Dienst erforderliche Geschäftslogik zur Schnittstelle hinzufügen. Das neu hinzugefügte ServiceImpl muss nur BaseSeServiceImpl erben und die neu hinzugefügte Geschäftslogik implementieren.
Vergessen Sie jedoch nicht den wichtigen Punkt: Es wird die Beans in den Konfigurationsdateien von Spring modifiziert .
<!-Generische Klassen können nicht instanziiert werden. Fügen Sie also eine Lazy-Init-Eigenschaft hinzu-> <bean id = "BaseSeService" Lazy-init = "true"> <Eigenschaft name = "sessionfactory" ref = "sessionfactory"/> </bean> <bean id = "categoryservice" parent = "baseService"/>/>
Töten Sie die Eigenschaft im ursprünglichen Kategorieservice und fügen Sie dann die übergeordnete Eigenschaft hinzu, um die Erbe von BaseSeService anzuzeigen. Konfigurieren Sie dann den BaseSeService und konfigurieren Sie die SessionFactory mit dem BaseSeService. Eine Sache, die zu beachten ist: Stellen Sie die Eigenschaft Lazy-Init auf True ein, da BasSeService eine generische Klasse ist und generische Klassen nicht instanziiert werden können. Zu diesem Zeitpunkt erfolgt die Extraktion der Serviceschicht.
2. Fügen Sie ein Konto in der Serviceschicht hinzu
Die Serviceschicht wurde gerade extrahiert. Jetzt ist es sehr einfach, einen Kontodienst zu schreiben:
Schreiben Sie zuerst eine Accountservice -Schnittstelle, um BaseSeService zu erben:
öffentliche Schnittstelle AccountService erweitert BaseService <Contoes> {// Beachten Sie, dass die Generika in BaseSeService jetzt Konto sind / * * einfach die neue Methode hinzufügen, die von Accountservice selbst erforderlich ist, und die öffentliche Methode befindet sich bereits in BaseService * /} Schreiben Sie dann eine Implementierungsklasse für AccountServiceImPL, um die BaseServiceImpl -Implementierungsklasse zu erben und die Accountservice -Schnittstelle zu implementieren:
public class AccountServiceImpl erweitert BaseSeServiceImpl <Contoes> implementiert Accountservice { / * * Implementieren Sie nur die neu hinzugefügten Methoden in der Accountservice -Schnittstelle. Die öffentliche Methode wurde in BaseSeServiceImpl */// Anmeldefunktion verwalten und wird später verbessert} Fügen Sie schließlich die folgende Konfiguration zu der Bean.xml -Datei hinzu:
<bean id = "Accountservice" Eltern = "BaseSeService" />
Auf diese Weise wurde ein neuer Service geschrieben. Wenn Sie in Zukunft einen Service hinzufügen müssen, folgen Sie diesem Prozess, was sehr bequem ist.
3. Aktionsextraktion
3.1 Daten in der Aktion in der Domäne (Anfrage, Sitzung, Anwendung usw.) speichern
Wir wissen, dass Sie in Aktion direkt ein ActionContext -Objekt über ActionContext.getContext () erhalten und das entsprechende Domänenobjekt über das Objekt dann erhalten können. Sie können das entsprechende Domänenobjekt auch injizieren, indem Sie die XXXAWare -Schnittstelle implementieren. Schauen wir uns zuerst diese beiden Methoden an:
Die Kategorie der öffentlichen Klassen erweitert ActionVorts -Implementierung von RequestAwe, SessionAWare, ApplicationAware {private Kategorie Kategorie; privater Kategoriedienste Kategorieservice; public void setCategoryService (categoryService categoryService) {this.categoryService = categoryService; } public String update () {System.out.println ("---- Update ----"); categoryService.update (Kategorie); Rückgabe "Index"; } public String Save () {System.out.println ("---- Save ----"); Rückgabe "Index"; } public String query () {// Lösung 1, verwenden Sie die entsprechende Karte, um das ursprüngliche integrierte Objekt zu ersetzen, so dass es keine Abhängigkeit von JSP gibt, aber die Menge an Code ist relativ groß // actioncontext.getContext (). // fügen Sie es in das Feld an, in das an Request // actioncontext.getContext (). GetSession (). Put ("CategoryList", CategoryService.Query ()); // In das Session -Feld einfügen // actioncontext.getContext (). // In die Anwendungsdomäne eingeben // Lösung 2, implementieren Sie die entsprechende Schnittstelle (RequestAware, SessionAWare, ApplicationAweare) und lassen Sie die entsprechende Kartenanforderung ("CategoryList", CategoryService.Query ())); Session.put ("CategoryList", CategoryService.Query ()); application.put ("categoryList", categoryService.query ()); Rückgabe "Index"; } öffentliche Kategorie getCategory () {Rückgabekategorie; } public void setCategory (Kategorie Kategorie) {this.category = category; } private map <String, Objekt> Anforderung; private map <String, Objekt> Sitzung; private map <String, Objekt> Anwendung; @Override public void setApplication (map <String, Objekt> Anwendung) {this.application = application; } @Override public void setSession (map <String, Objekt> Sitzung) {this.Session = session; } @Override public void setRequest (MAP <String, Objekt> Anforderung) {this.Request = request; }} Es ist nach wie vor die Kategorieklasse, die die drei Hauptrahmen im vorherigen Abschnitt integriert. Wir haben dieser Methode eine Abfragemethode hinzugefügt. Bei dieser Methode speichern wir die Ergebnisse der Abfrage in der Anforderungsdomäne, der Sitzungsdomäne und der Anwendungsdomäne. Die erste Methode besteht darin, ActionContext direkt zu verwenden, um es zu implementieren. Es ist keine Schnittstelle erforderlich, aber der Code ist groß; Die zweite Methode implementiert die Schnittstellen von RequestAwe, Sessionaware und ApplicationAweAwe und drei abstrakten Methoden zur Implementierung der Schnittstelleninjektion, Sitzung und Anwendung und zuordnen sie dann den entsprechenden Mitgliedsvariablen zu, sodass die Abfrageergebnisse in der Domäne in der Abfragemethode gespeichert werden können. Dieses Codevolumen scheint größer zu sein als die erste Methode ... aber wir können sie extrahieren und zuerst lesen.
Wir fügen zu Index.jsp eine neue Abfrageverbindung hinzu, um zu testen, ob die Abfrageergebnisse angezeigt werden können:
<%@ page Language = "java" import = "java.util. <html> <Head> <titels> My JSP 'INDEX.JSP' STORT -Seite </title> </head> <body> <a href = "$ {pageContext.Request.ContextPath} /category_update.Action?category.id=2&category.type=gga&category.hot=hot=fal. href = "category_save.action"> Zugriff speichern </a> <a href = "category_query.action"> Abfragen Sie alle Kategorien ab </a> <br/> <c: foreach items = "$ {requestScope.categoryList}" var = "category"> $ {category.id} | $ {category.type} | $ {category.hot} <br/> </c: foreach> <c: foreach items = "$ {sesionscope.categorylist}" var = "category"> $ {category.id} | $ {category.type} | $ {category.hot} <br/> </c: foreach> <c: foreach items = "$ {applicationscope.categorylist}" var = "category"> $ {category.id} | $ {category.type} | $ {category.hot} <br/> </c: foreach> </body> </html> 3.2 Basisreaktion extrahieren
Wie gerade erwähnt, hat die zweite Methode ein größeres Codevolumen, aber wir können eine Basiswirkung extrahieren, um die mit diesen Domänen verbundenen Operationen spezifisch zu verarbeiten.
öffentliche Klasse Basacection erweitert ActionVorts implementiert RequestAwe, SessionAWare, ApplicationAware {Protected Map <String, Objekt> Anforderung; geschützte Karte <String, Objekt> Sitzung; Protected Map <String, Objekt> Anwendung; @Override public void setApplication (map <String, Objekt> Anwendung) {this.application = application; } @Override public void setSession (map <String, Objekt> Sitzung) {this.Session = session; } @Override public void setRequest (MAP <String, Objekt> Anforderung) {this.Request = request; }} Wenn unsere eigene Aktion diese Domänenobjekte zum Speichern von Daten verwenden muss, können wir die Basisanlagen direkt erben und wir können direkt Anforderungs-, Sitzungs- und Anwendungsobjekte verwenden. Daher lautet die geänderte Kategorie wie folgt:
Die Kategorie der öffentlichen Klassen erweitert die Basisreaktion {private Kategorie Kategorie; <pre name = "code"> private categoryService categoryService; public void setCategoryService (categoryService categoryService) {this.categoryService = categoryService; } public String update () {System.out.println ("--- Update ----"); CategoryService.Update (Kategorie); Rückgabe "Index"; } public String Save () {System.out.println ("---- Save -----"); return "index"; } public String query () {request.put ("categoryList", categoryService.query ()); Session.put ("CategoryList", CategoryService.Query ()); application.put ("categoryList", categoryService.query ()); Rückgabe "Index"; } öffentliche Kategorie getCategory () {Rückgabekategorie; } public void setCategory (Kategorie Kategorie) {this.category = category; }} Alle Aktionen, die Anforderungs-, Sitzungs- und Anwendungsfelder verwenden müssen, werden einfach direkt geerbt, was sehr bequem ist.
3.3 Parameter abrufen (modelldurchdringlich)
Sehen wir uns weiterhin die obige Kategorieklasse an. Es gibt eine Mitgliedervariablenkategorie, bei der es sich um ein Pojo handelt. Das Definieren dieser Variablen und das Schreiben der Satz- und Erhaltensmethoden ist, damit die JSP -Seite über die an die URL angehängten Parameter übergeben wird. Die Parameter sind Attribute im Kategorieobjekt wie ID, Typ usw., aber die Parameter in der URL müssen als Kategorie geschrieben werden. ID, Kategorie. Wir können modelldelen verwenden, um das Problem leichter zu lösen.
Die Kategorie der öffentlichen Klassen erweitert Baseacction implementiert modelldelen <kategorie> {private Kategorie Kategorie; // Unter Verwendung der modelldurchschnittlichen Schnittstelle muss die Methode getModel () implementiert werden. Diese Methode wird das zurückgegebene Element an die Spitze des stack @Override öffentlichen Kategorie getModel () {category = new category () bringen; Rückgabekategorie; } <pre name = "code"> private categoryService categoryService; public void setCategoryService (categoryService categoryService) {this.categoryService = categoryService; } public String update () {System.out.println ("---- Update ----"); categoryService.update (Kategorie); Rückgabe "Index"; } public String Save () {System.out.println ("---- Save ----"); Rückgabe "Index"; } public String query () {request.put ("categoryList", categoryService.query ()); Session.put ("CategoryList", CategoryService.Query ()); application.put ("categoryList", categoryService.query ()); Rückgabe "Index"; }} Auf diese Weise müssen wir die mühsamen Parameter wie Kategorie nicht auf der JSP -Seite an der Rezeption einbeziehen. Schauen Sie sich den modelldurchschnittlichen Teil der JSP -Seite an:
<%@ page Language = "java" import = "java.util. <html> <Head> <titels> My JSP 'INDEX.JSP' STORT -Seite </title> </head> <body> <a href = "$ {pageContext.Request.ContextPath} /category_update.Action?category.id=2&category.type=gga&category.hot=hot=fal. href="category_save.action?id=1&type=haha&hot=true">Test ModelDriven</a> <a href="category_query.action">Query all categories</a><br/> <c:forEach items="${requestScope.categoryList }" var="category"> ${category.id } | $ {category.type} | $ {category.hot} <br/> </c: foreach> <c: foreach items = "$ {sesionscope.categorylist}" var = "category"> $ {category.id} | $ {category.type} | $ {category.hot} <br/> </c: foreach> <c: foreach items = "$ {applicationscope.categorylist}" var = "category"> $ {category.id} | $ {category.type} | $ {category.hot} <br/> </c: foreach> </body> </html> Das Testergebnis ist, dass Kategorie erhalten werden kann und alle ID-, Typ- und heißen Attribute gut zugeordnet sind. Wir können sehen, dass wir durch die Implementierung der modelldurchschnittlichen Schnittstelle Parameter in der URL problemlos tragen können. In Aktion müssen wir nur die GetModel -Methode implementieren und ein neues Objekt zurückgeben. Zu diesem Zeitpunkt ist es leicht zu glauben, dass es definitiv viele solcher Modelle in Streben geben wird, die erhalten werden müssen, sodass wir diesen Teil auch in Basaktionen extrahieren müssen.
3.4 modellbezogenes Extrakt für Basisreaktionen
Zunächst fügen wir den Code des Modells wie folgt zur Basisreaktion hinzu:
// Da es viele verschiedene Modelle gibt, die modelldurchdringlich erfordern, verwenden wir generische öffentliche Klassen -Basisaction <T> ActionVort -Implements RequestAwe, SessionAware, ApplicationAware, modelldelen <T> {Protected Map <String, Objekt> Anforderung; geschützte Karte <String, Objekt> Sitzung; Protected Map <String, Objekt> Anwendung; geschütztes T -Modell; @Override public void setApplication (map <String, Objekt> Anwendung) {this.application = application; } @Override public void setSession (map <String, Objekt> Sitzung) {this.Session = session; } @Override public void setRequest (MAP <String, Objekt> Anforderung) {this.Request = request; } @Override public t getModel () {// hier, neu eine entsprechende Instanz, indem das t in. Parameterizedtype type = (parameterizedtype) this.getClass (). GetGenericsuperClass (); Class clazz = (class) type.getActualtTypeargumente () [0]; try {model = (t) clazz.newinstance (); } catch (Ausnahme e) {neue runTimeException (e) werfen; } Rückgabemodell; }} Nach der Extraktion nimmt der Code in der Kategorie ab und nimmt ab:
// Basiswirkung in Erben und Hinzufügen von generischer öffentlicher Klassenkategorie erweitert Baseaction <Gategorie> {private Kategoriedienste CategoryService; public void setCategoryService (categoryService categoryService) {this.categoryService = categoryService; } public String update () {System.out.println ("---- Update ----"); CategoryService.Update (Modell); // Modell verwenden direkt "Index"; } public String Save () {System.out.println ("---- Save ----"); System.out.println (Modell); // Modell direkt verwenden, um "Index" zurückzugeben; } public String query () {request.put ("categoryList", categoryService.query ()); Session.put ("CategoryList", CategoryService.Query ()); application.put ("categoryList", categoryService.query ()); Rückgabe "Index"; }} Zu diesem Zeitpunkt gibt es eine andere Sache, die sich nicht gut anfühlt, nämlich der Kategorie -Service der Mitgliedsvariablen, der in der Kategorie immer existiert hat. Da die Kategorie Methoden im CategoryService -Objekt verwendet, muss dieses Objekt erstellt und eine festgelegte Methode injiziert werden. Dies führt zu einem Nachteil: Wenn viele Aktionen Kategorienservice verwenden müssen, müssen in ihren Aktionen das Objekt und die festgelegte Methode erstellt werden. Wenn in einer Aktion mehrere verschiedene Serviceobjekte verwendet werden, müssen alle erstellt werden, was sehr kompliziert wird.
3.5 Service zum Basisreaktion extrahieren
Als Reaktion auf das obige Problem extrahieren wir alle Serviceobjekte im Projekt in die Basisreaktion, um es zu erstellen. Auf diese Weise können sie nach anderen Aktionen Basisreaktion den Dienst nutzen, den sie verwenden möchten:
// Ich habe den Inhalt in der Basis der Basis der öffentlichen Klasse eingestuft. geschützter Accountservice Accountservice; public void setCategoryService (categoryService categoryService) {this.categoryService = categoryService; } public void setAccountService (Accountservice) AccountService) {this.accountService = Accountservice; } // Domänenobjekt geschützte Karte <String, Objekt> Anforderung; geschützte Karte <String, Objekt> Sitzung; Protected Map <String, Objekt> Anwendung; @Override public void setApplication (map <String, Objekt> Anwendung) {this.application = application; } @Override public void setSession (map <String, Objekt> Sitzung) {this.Session = session; } @Override public void setRequest (MAP <String, Objekt> Anforderung) {this.Request = request; } // modelldelen geschütztes T -Modell; @Override public t getModel () {parameterizedtype type = (parameterizedtype) this.getClass (). GetGenerics -uperClass (); Class clazz = (class) type.getActualtTypeargumente () [0]; try {model = (t) clazz.newinstance (); } catch (Ausnahme e) {neue runTimeException (e) werfen; } Rückgabemodell; }} Dies macht die Kategorie mehr Aktualisierung: Die Kategorie der öffentlichen Klassen erweitert die Basisaction <kategorie> {public String update () {System.out.println ("--- update ----"); categoryService.update (Modell); Rückgabe "Index"; } public String Save () {System.out.println ("--- speichern ----"); System.out.println (Modell); Rückgabe "Index"; } public String query () {request.put ("categoryList", categoryService.query ()); Session.put ("CategoryList", CategoryService.Query ()); application.put ("categoryList", categoryService.query ()); Rückgabe "Index"; }} Einige Leute mögen fragen, ob es nicht überflüssig sein wird, wenn so viele Servicebobjekte in Basisanlagen injiziert werden? Dies gilt nicht, denn selbst wenn es nicht in Basisreaktion geschrieben ist, erstellt der Federbehälter dieses Objekt, was keine Rolle spielt. Im Gegenteil, das Serviceobjekt wird in Basiswirkung gestellt und ist bequemer für die Entwicklung anderer Aktionen. Darüber hinaus muss die Basisreaktion nicht der Struts.xml -Datei zugeordnet werden, da kein JSP die Basisreaktion anfordert. Es gilt nur für andere Aktionen, um zu erben.
Eine andere Sache zu vergessen: Das heißt, die Konfiguration in beans.xml zu ändern:
<!-- If it is a prototype type, it is created when used, not automatically when starting--> <bean id="baseAction" scope="prototype"> <property name="categoryService" ref="categoryService"></property> <property name="accountService" ref="accountService"></property> </bean> <bean id="categoryAction" scope="prototype" Eltern = "Basisreaktion"/>
Fügen Sie eine neue Basis -Bean hinzu, passen Sie alle Serviceobjekte im Projekt als Eigenschaft an und töten Sie die Eigenschaft in der ursprünglichen Kategorie.
Wenn wir in Zukunft eine neue XXXAction schreiben wollen, können wir die Basiswirkung direkt erben. Wenn ein Dienst in XXXAction verwendet wird, können wir ihn direkt verwenden. Wir müssen nur eine Bean hinzufügen, die XXXACTION in der bean.xml -Datei entspricht und den Sprung in der Datei stritzs.xml konfigurieren kann.
4. Ändern Sie XML in Annotation
Wir können sehen, dass das Projekt immer größer und mehr Konfigurationen in Beans.xml geben wird und viele Konfigurationen überflüssig sind. Um es einfacher zu entwickeln, ändern wir jetzt die Konfiguration von XML in Anmerkungen. Schauen wir uns zunächst die Konfiguration in beans.xml an:
Dies sind die Bohnen, die wir geschrieben haben, als wir die Umgebung bauten und sie extrahierten. Diese müssen in Anmerkungen umgewandelt werden. Ersetzen wir sie Stück für Stück: Ersetzen Sie zuerst den Service -Teil, der drei Teile enthält: BaseSeService, CategoryService und Accountservice. Ersetzen Sie wie folgt:
Dann töten Sie den entsprechenden Teil in Beans.xml. Ändern Sie als Nächstes den Aktionsteil, hauptsächlich Basisreaktion, Kategorie und Konto und ersetzen Sie ihn wie folgt:
Töten Sie dann die Konfiguration des Aktionsteils in beans.xml und fügen Sie schließlich die folgende Konfiguration zur Bean.xml -Datei hinzu, und Sie können die Annotation verwenden.
<Kontext: Komponenten-scan-Basis-Package = "cn.it.shop .."/>
Einige Leute fragen sich vielleicht: Warum unterscheiden sich Service und Handlung bei Anmerkungen? @Service wird im Dienst verwendet und @Controller wird in der Aktion verwendet? Tatsächlich ist es dasselbe, nur um sie von verschiedenen Bohnenschichten für das leichte Lesen zu unterscheiden.
Die Quellcode -Download -Adresse des gesamten Projekts: //www.vevb.com/article/86099.htm
Originaladresse: http://blog.csdn.net/eson_15/article/details/51297698
Das obige ist der gesamte Inhalt der zweiten Schlacht des SSH Framework Online Mall Project. Ich hoffe, es wird für das Lernen aller hilfreich sein, und ich hoffe, jeder wird Wulin.com mehr unterstützen.