Savez-vous ce qu'est le printemps ?

Tout d’abord, présentons brièvement le printemps.

Spring est un framework de développement Java léger open source avec deux cœurs : Inversion de contrôle (IoC) et Aspect Oriented (AOP). Le framework Java Spring gère les transactions de manière flexible et déclarative, améliorant ainsi l'efficacité et la qualité du développement.

(Tutoriel recommandé : Tutoriel d'introduction à Java)

Le framework Spring ne se limite pas au développement côté serveur. Toute application Java peut bénéficier de Spring en termes de simplicité, de testabilité et de couplage lâche. Le framework Spring est également une plate-forme super-glue. En plus de fournir ses propres fonctions, il offre également la possibilité de coller d'autres technologies et frameworks.

Ensuite, présentons le contenu spécifique en détail.

Inversion de contrôle (IOC)

Dans le passé, le code de la couche de logique métier était susceptible d'être écrit comme ceci :

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

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

Comme le montre le ci-dessus, PersonDaoBean est créé dans l'application et maintenu. Ce que l'on appelle l'inversion de contrôle signifie que l'application elle-même n'est pas responsable de la création et de la maintenance des objets dépendants. La création et la maintenance des objets dépendants relèvent de la responsabilité du conteneur externe. De cette manière, le contrôle est transféré de l’application vers le conteneur externe. Le transfert de contrôle est appelé inversion.

Injection de dépendance

Lorsque nous transmettons l'objet de dépendance au conteneur externe pour la création, la classe PersonServiceBean peut être modifiée comme suit :

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

La soi-disant dépendance injection signifie : Pendant l'exécution, le conteneur externe injecte dynamiquement les objets dépendants dans le composant.

Pourquoi utiliser Spring ?

Au moins à mon avis, introduire Spring dans le projet peut immédiatement apporter les avantages suivants :

Réduire le couplage entre les composants et réaliser un découplage entre les différentes couches du logiciel.

Vous pouvez utiliser de nombreux services fournis par les conteneurs, tels que les services de gestion des transactions, les services de messagerie, etc. Lorsque nous utilisons des conteneurs pour gérer les transactions, les développeurs n'ont plus besoin de contrôler manuellement les transactions, ni de gérer une propagation complexe des transactions.

Le conteneur fournit une prise en charge du mode singleton et les développeurs n'ont plus besoin d'écrire eux-mêmes le code d'implémentation.

Les conteneurs fournissent la technologie AOP, qui peut facilement être utilisée pour implémenter des fonctions telles que l'interception des autorisations et la surveillance de l'exécution.

Les conteneurs fournissent de nombreuses classes auxiliaires. L'utilisation de ces classes peut accélérer le développement d'applications, telles que : JdbcTemplate, HibernateTemplate.

Spring fournit une prise en charge intégrée des frameworks d'applications traditionnels, tels que l'intégration d'Hibernate, JPA, Struts, etc., ce qui facilite le développement d'applications.

Avantages de l'utilisation de Spring

Nous avons répertorié en détail les avantages de l'utilisation du framework Spring ci-dessus. Nous développerons uniquement le deuxième point. Lors de l'utilisation du framework Spring, nous pouvons utiliser de nombreux services fournis par le conteneur.

Imaginez que si vous n'utilisez pas le framework Spring, alors utiliser le framework Hibernate pour les opérations de transaction devrait être :

Opérations de transaction Hibernate :

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

Ni le framework Spring ni le framework Hibernate ne sont utilisés, et la technologie JDBC la plus primitive est directement utilisée pour les opérations de transaction. Le code doit être :

Opération de transaction JDBC :

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();
}

. Et si nous utilisons le framework Spring, nous n'avons plus besoin de contrôler manuellement les transactions. De plus, si nous utilisons le framework Spring, nous n'avons pas besoin de gérer un comportement complexe de propagation des transactions. Illustrons cela par un exemple.

(Tutoriel vidéo recommandé : cours java )

Par exemple, il y a le code :

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=?");  
    }
}

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

Si on n'utilise pas le framework Spring, pour les deux besoins Business suivants, comment devons-nous procéder ?

La première exigence métier possible : nécessite que Bean1.update() et Bean2.save() soient exécutés dans la même transaction.

La deuxième exigence commerciale possible : il est nécessaire d'enregistrer le journal des opérations, que la transaction de Bean1.update() réussisse ou non.

Si vous n'utilisez pas le framework Spring, pour la première exigence métier possible, notre solution s'exprime en code :

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=?");  
    }
}

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

Pour la deuxième exigence métier possible, nous ne pouvons pas la compléter en modifiant le code, car Bean1.update() ouvre une transaction et Bean2.save() ouvre également une transaction. L'annulation de la transaction démarrée par Bean1.update() n'affectera pas la transaction ouverte par Bean2.save().

Si nous utilisons le framework Spring, nous pouvons facilement répondre à ces deux exigences métier grâce à la configuration déclarative des attributs de transaction.

Nécessite que Bean1.update() et Bean2.save() soient exécutés dans la même transaction. Il nous suffit de changer le code en :

@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=?");    
    }
}

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

nécessite que le journal soit enregistré, que la transaction de Bean1.update() réussisse ou non. Il suffit de changer le code en :

@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=?");    
    }
}

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

Division des concepts légers et lourds

Les gens demandent souvent si Spring est un framework léger ou un framework lourd ? En fait, le fait qu’une application soit classée comme légère ou lourde dépend principalement du nombre de services qu’elle utilise. Plus le nombre de services utilisés est important, plus le conteneur doit effectuer de travail pour les objets Java ordinaires, ce qui affectera inévitablement le temps de publication de l'application ou les performances d'exécution.

Pour le conteneur Spring, il fournit de nombreux services, mais ces services ne sont pas ouverts par l'application par défaut. L'application a besoin d'un certain service et doit spécifier l'utilisation de. le service. si l'application utilise très peu de services, par exemple en utilisant uniquement les services de base de Spring, alors nous pouvons considérer l'application comme légère. Si l'application utilise la plupart des services fournis par Spring, alors l'application est lourde. Le conteneur EJB actuel est lourd car il fournit par défaut aux applications toutes les fonctions de la spécification EJB.

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!