Wissen Sie, was Frühling ist?

Lassen Sie uns zunächst kurz den Frühling vorstellen.

Spring ist ein leichtes Open-Source-Java-Entwicklungsframework mit zwei Kernen: Inversion of Control (IoC) und Aspect Orientation (AOP). Das Java Spring-Framework verwaltet Transaktionen flexibel auf deklarative Weise und verbessert so die Entwicklungseffizienz und -qualität.

(Empfohlenes Tutorial: Java-Einführungs-Tutorial)

Das Spring-Framework ist nicht auf die serverseitige Entwicklung beschränkt. Jede Java-Anwendung kann von Spring hinsichtlich Einfachheit, Testbarkeit und loser Kopplung profitieren. Das Spring-Framework ist auch eine Sekundenkleberplattform. Es bietet nicht nur eigene Funktionen, sondern auch die Möglichkeit, andere Technologien und Frameworks zu kleben.

Als nächstes stellen wir den spezifischen Inhalt im Detail vor.

Inversion of Control (IOC)

In der Vergangenheit wurde der Code der Geschäftslogikschicht wahrscheinlich so geschrieben:

public class PersonServiceBean {
     private PersonDao personDao = new PersonDaoBean();

      public void save(Person person){
            personDao.save(person);
     }
}

Aus dem oben Gesagten ist ersichtlich, dass PersonDaoBean innerhalb der Anwendung erstellt und verwaltet wird. Die sogenannte Umkehrung der Kontrolle bedeutet, dass die Anwendung selbst nicht für die Erstellung und Wartung abhängiger Objekte verantwortlich ist. Die Erstellung und Wartung abhängiger Objekte liegt in der Verantwortung des externen Containers. Auf diese Weise wird die Kontrolle von der Anwendung auf den externen Container übertragen. Die Übertragung der Kontrolle wird als Inversion bezeichnet.

Abhängigkeitsinjektion

Wenn wir das Abhängigkeitsobjekt zur Erstellung an den externen Container übergeben, kann die PersonServiceBean-Klasse wie folgt geändert werden:

public class PersonServiceBean {
     private PersonDao personDao ;
     // 通过构造器参数，让容器把创建好的依赖对象注入进PersonServiceBean，当然也可以使用setter方法进行注入。
     public PersonServiceBean(PersonDao personDao){
         this.personDao=personDao;
     }  
     public void save(Person person){
         personDao.save(person);
     }
}

Die sogenannte Abhängigkeitsinjektion bedeutet: Zur Laufzeit fügt der externe Container dynamisch Abhängigkeiten hinzu Das Objekt wird in die Komponente eingefügt.

Warum Frühling nutzen?

Zumindest meiner Meinung nach kann die Einführung von Spring im Projekt sofort folgende Vorteile bringen:

Reduzieren Sie die Kopplung zwischen Komponenten und erreichen Sie eine Entkopplung zwischen den verschiedenen Schichten der Software.

Sie können viele von Containern bereitgestellte Dienste nutzen, z. B. Transaktionsverwaltungsdienste, Messaging-Dienste usw. Wenn wir Container zum Verwalten von Transaktionen verwenden, müssen Entwickler Transaktionen nicht mehr manuell steuern oder sich mit der komplexen Transaktionsweitergabe befassen.

Container bieten Unterstützung für den Singleton-Modus, und Entwickler müssen nicht mehr selbst Implementierungscode schreiben.

Container stellen AOP-Technologie bereit, mit der sich problemlos Funktionen wie das Abfangen von Berechtigungen und die Laufzeitüberwachung implementieren lassen.

Container bieten viele Hilfsklassen. Die Verwendung dieser Klassen kann die Anwendungsentwicklung beschleunigen, z. B. JdbcTemplate, HibernateTemplate.

Spring bietet integrierte Unterstützung für gängige Anwendungsframeworks wie die Integration von Hibernate, JPA, Struts usw., was die Anwendungsentwicklung erleichtert.

Vorteile der Verwendung von Spring

Wir haben die Vorteile der Verwendung des Spring-Frameworks oben ausführlich aufgeführt. Wir werden nur auf den zweiten Punkt näher eingehen. Bei Verwendung des Spring-Frameworks können wir zahlreiche vom Container bereitgestellte Dienste nutzen.

Stellen Sie sich vor, wenn Sie das Spring-Framework nicht verwenden, sollte die Verwendung des Hibernate-Frameworks für Transaktionsvorgänge wie folgt sein: Am primitivsten Um Transaktionsoperationen mithilfe der JDBC-Technologie durchzuführen, sollte der Code wie folgt lauten:

JDBC-Transaktionsoperation:

public void save(){
    Session session = sessionFactory.getCurrentSession();
    session.beginTransaction();
    Info info = new Info("Spring框架");
    info.setContent("阿昀手把手教你学习Spring框架");
    session.save(info);
    session.getTransaction().commit();
}

Und wenn wir das Spring-Framework verwenden, müssen wir Transaktionen nicht mehr manuell steuern. Wenn wir das Spring-Framework verwenden, müssen wir uns außerdem nicht mit dem komplexen Verhalten der Transaktionsweitergabe befassen. Lassen Sie uns dies anhand eines Beispiels veranschaulichen.

(Video-Tutorial-Empfehlung:

)

Zum Beispiel gibt es Code:

Connection conn = null;
try {
    ......
    conn.setAutoCommit(false);
    Statement stmt = conn.createStatement();
    stmt.executeUpdate("update person where name='叶天'");
    conn.commit();
    ......
} catch (Exception e) { 
    conn.rollback(); 
} finally {
    conn.close();
}

public void payment(){
    Bean1.update(); // 更新金额
    Bean2.save(); // 记录操作日志
}

public class Bean1 { 
    public void update(){ // 注意：下面省略了一些代码
        Connection conn = null;
        conn.setAutoCommit(false);
        Statement.executeUpdate("update account set amount=? where id=?");  
    }
}

Die erste mögliche Geschäftsanforderung: erfordert, dass Bean1.update() und Bean2.save() in derselben Transaktion ausgeführt werden.

Die zweite mögliche Geschäftsanforderung: Es ist erforderlich, das Betriebsprotokoll aufzuzeichnen, unabhängig davon, ob die Transaktion von Bean1.update() erfolgreich ist oder nicht.

Wenn Sie das Spring-Framework nicht verwenden, lautet unsere im Code ausgedrückte Lösung für die erste mögliche Geschäftsanforderung:

public class Bean2 {
    public void save(){ // 注意：下面省略了一些代码
        Connection conn = null;
        conn.setAutoCommit(false);
        Statement.executeUpdate("insert into Log (content) values (?)");
    }
}

public void payment(){
    Connection conn = null;
    conn.setAutoCommit(false);
    Bean1.update(conn); // 更新金额
    Bean2.save(conn); // 记录操作日志
    // ...提交或回滚事务
}

public class Bean1 { 
    public void update(Connection conn){ // 注意：下面省略了一些代码
        Statement.executeUpdate("update account set amount=? where id=?");  
    }
}

Für die zweite mögliche Geschäftsanforderung müssen wir den Code nicht ändern, um sie zu vervollständigen, da Bean1. update() startet eine Transaktion und Bean2.save() startet auch eine Transaktion. Das Rollback der von Bean1.update() gestarteten Transaktion hat keine Auswirkungen auf die von Bean2.save() gestartete Transaktion.

Wenn wir das Spring-Framework verwenden, können wir diese beiden Geschäftsanforderungen problemlos durch die Konfiguration deklarativer Transaktionsattribute erfüllen.

Erfordert die Ausführung von Bean1.update() und Bean2.save() in derselben Transaktion. Wir müssen nur den Code ändern in:

public class Bean2 {
    public void save(Connection conn){ // 注意：下面省略了一些代码
        Statement.executeUpdate("insert into Log (content) values (?)");
    }
}

@Transactional(propagation=Propagation.Required)
public void payment(){
    Bean1.update(); // 更新金额
    Bean2.save(); // 记录日志
}

public class Bean1 {
    @Transactional(propagation=Propagation.Required)
    public void update(){
        executeUpdate("update account set amount=? where id=?");    
    }
}

Erfordert, dass das Protokoll aufgezeichnet werden muss, unabhängig davon, ob die Transaktion von Bean1.update() erfolgreich ist oder nicht. Wir müssen nur den Code ändern in:

public class Bean2 {
    @Transactional(propagation=Propagation.Required)
    public void save(){
        executeUpdate("insert into Log (content) values (?)");
    }
}

@Transactional(propagation=Propagation.Required)
public void payment(){
    Bean1.update(); // 更新金额
    Bean2.save(); // 记录日志
}

public class Bean1 {
    @Transactional(propagation=Propagation.Required)
    public void update(){
        executeUpdate("update account set amount=? where id=?");    
    }
}

Die Unterteilung in Leicht- und Schwergewichtskonzepte

Die Leute fragen oft, ob Spring ein leichtes Framework oder ein schweres Framework ist? Ob eine Anwendung als leichtgewichtig oder schwergewichtig eingestuft wird, hängt tatsächlich hauptsächlich davon ab, wie viele Dienste sie nutzt. Je mehr Dienste verwendet werden, desto mehr Arbeit muss der Container für gewöhnliche Java-Objekte leisten, was sich unweigerlich auf die Veröffentlichungszeit der Anwendung oder die Ausführungsleistung auswirkt.

Für den Spring-Container werden viele Dienste bereitgestellt, aber diese Dienste werden standardmäßig nicht für die Anwendung geöffnet und müssen die Verwendung des Dienstes angeben, wenn die Anwendung nur wenige verwendet Wenn beispielsweise nur Spring-Kerndienste verwendet werden, können wir davon ausgehen, dass die Anwendung zu diesem Zeitpunkt leichtgewichtig ist. Wenn die Anwendung die meisten von Spring bereitgestellten Dienste verwendet, ist die Anwendung schwergewichtig. Der aktuelle EJB-Container ist ein Schwergewicht, da er Anwendungen standardmäßig alle Funktionen der EJB-Spezifikation zur Verfügung stellt.

Das obige ist der detaillierte Inhalt vonWissen Sie, was Frühling ist?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!