Maison > Article > Java > Comment Java SpringBoot intègre-t-il JSP et MyBatis ?

Comment Java SpringBoot intègre-t-il JSP et MyBatis ?

王林avant: 2023-05-11 17:46:06930parcourir

Démarrer avec Spring Boot Starter

Pour exécuter un projet Spring traditionnel, vous devez non seulement importer diverses dépendances, mais également configurer divers fichiers de configuration XML, ce qui est très fastidieux, cependant, après la création du projet Spring Boot, même sans. l'écriture de n'importe quel code peut être exécutée directement sans aucune configuration, tout cela grâce au mécanisme de démarrage de Spring Boot

Spring Boot extrait divers scénarios du développement quotidien d'applications d'entreprise et les transforme en démarreurs un par un. Il intègre diverses dépendances qui peuvent être utilisées dans ce cadre. Les utilisateurs n'ont qu'à introduire la dépendance de démarrage dans Maven, et SpringBoot peut analyser automatiquement les informations à charger et démarrer la configuration par défaut correspondante. Le démarreur fournit une grande quantité de configuration automatique, libérant les utilisateurs des tracas liés à la gestion de diverses dépendances et configurations. Tous ces starters suivent les configurations par défaut conventionnelles et permettent aux utilisateurs d'ajuster ces configurations, c'est-à-dire en suivant le principe de "La convention est supérieure à la configuration"

Tous les starters ne sont pas officiellement fournis par Spring Boot, et il existe aussi quelques starters Il est fourni par des fournisseurs de technologies tiers, tels que druid-spring-boot-starter et mybatis-spring-boot-starter, etc. Bien sûr, il existe également des technologies tierces individuelles. Spring Boot ne fournit officiellement pas de démarreur, et les fournisseurs de technologies tiers ne fournissent pas non plus de démarreur. En prenant spring-boot-starter-web comme exemple, il peut en fournir presque. toutes les dépendances nécessaires aux scénarios de développement Web. Par conséquent, lorsque vous utilisez Spring Boot pour développer un projet Web, il vous suffit d'introduire le Starter, sans importer en plus le serveur Web et les autres dépendances Web

    <!--SpringBoot父项目依赖管理-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.13</version>
        <relativePath/>
    </parent>

    <dependencies>
        <!--导入 spring-boot-starter-web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        ...
    </dependencies>
</project>

Vous pouvez rencontrer un problème, c'est-à-dire dans la configuration du pom.xml ci-dessus, lors de l'introduction de la dépendance spring-boot-starter-web, sa version n'est pas spécifiée, mais dans l'arborescence des dépendances, nous voyons que toutes les dépendances ont des informations de version. Alors, où ces informations de version sont-elles contrôlées. ?

En fait, ces informations de version sont uniformément contrôlées par

spring-boot-starter-parent

(Version Arbitration Center).

spring-boot-starter-parent

spring-boot-starter-parent est la dépendance parent de tous les projets Spring Boot. Elle est appelée le centre d'arbitrage de version de Spring Boot et peut gérer certaines dépendances courantes au sein du projet. Gestion unifiée.

<!--SpringBoot父项目依赖管理-->
<parent>  
    <groupId>org.springframework.boot</groupId>   
    <artifactId>spring-boot-starter-parent</artifactId>    
    <version>2.4.5</version>    
</parent>

Les projets Spring Boot peuvent obtenir des configurations par défaut raisonnables en héritant de spring-boot-starter-parent, qui fournit principalement les fonctionnalités suivantes :

1.1 SpringBoot définit le numéro de port

server:
  port: 8989 #配置端口

1.2 SpringBoot définit le nom du projet

server:
  servlet:
    context-path: /springboot   #配置项目的虚拟路径(根路径) 项目名使用/开头

1.3 Division du fichier de configuration SpringBoot

spring:
  profiles:
    active: dev  #开发环境

Comment Java SpringBoot intègre-t-il JSP et MyBatis ? 1.4 SpringBoot ouvre le journal

# 显示sql
logging:
  level:
    cn.kgc.springboot.mapper: debug  #开启日志

1.5 SpringBoot implémente le déploiement à chaud

Dans le processus d'ouverture du projet Web , Habituellement, chaque fois que nous modifions le code, nous devons redémarrer le projet et le redéployer. Mais à mesure que les projets deviennent de plus en plus grands, chaque démarrage prend du temps. Par conséquent, le déploiement à chaud est une technologie très innovante. Avec le déploiement à chaud, nous pouvons considérablement améliorer notre efficacité de développement

spring-boot-devtools implémente le déploiement à chaud

1 Introduire des dépendances

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-devtools</artifactId>
</dependency>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork> <!-- 如果devtools不生效  请设置该属性 -->
            </configuration>
        </plugin>
    </plugins>
</build>

3. Configurez le fichier application.yml

devtools:
  restart:
    enabled: true #开启热部署

4. Modifiez les paramètres de l'idée

File-Settings-Compiler et cochez Build Project automatiquement

5. Configurez le registre

ctrl + shift + alt. + /, sélectionnez Registre, cochez AutoMake du compilateur lors de l'exécution de l'application

1.6 SpringBoot active la requête de pagination

1 Introduisez les dépendances :

<dependency>
     <groupId>com.github.pagehelper</groupId>
     <artifactId>pagehelper-spring-boot-starter</artifactId>
     <version>1.2.12</version>
</dependency>

----------------------------------------------
 <dependency>
     <groupId>com.github.pagehelper</groupId>
     <artifactId>pagehelper-spring-boot-starter</artifactId>
     <version>1.2.10</version>
</dependency>

2. Configurez le fichier application.yml (vous pouvez utiliser la valeur par défaut sans le configurer)

# pageHelper分页配置
pagehelper:
  helper-dialect: mysql  #数据库类型
  reasonable: true   #分页合理化 page<1 查询第一页 page >pageNumber 查询最后一页
  support-methods-arguments: true  # 支持mapper接口传递参数开启分页
  params: count=countSql  #用于从对象中根据属性名取值

3. Écrivez le contrôleur, la couche métier, la couche de persistance pour tester

@Override
public PageInfo<User> getPage(int pageNum, int pageSize) {

    PageHelper.startPage(pageNum, pageSize);

    List<User> userList = userMapper.selectList();

    PageInfo<User> pageInfo = new PageInfo<>(userList);

    return pageInfo;
}

gestion des objets springBoot

Gérer les objets
La façon de gérer les objets au printemps :
1. utilisez les paramètres des balises bean dans le fichier Gestion des objets
```
<bean id="" class="xxx.xxx.xxx"></bean>
```

Comment Springboot gère les objets :

1 Utilisez la méthode de configuration pour créer des objets

. springboot prend en charge l'utilisation de l'ajout d'annotations

@Configuration

Sur la classe de configuration, cette classe, en tant que classe de configuration, est équivalente au fichier de configuration spring. Cette annotation ne peut être utilisée que sur la classe. Utilisez l'annotation @Bean sur la méthode dans la classe de configuration, qui est équivalente à la balise bean dans le fichier de configuration Spring

@Configuration
public class MyConfiguration{
    @Bean
    public User getUser(){
        return new User();
    }
    @Bean
    public Student getStudent(){
        return new Student();
    }
}

2 Utilisez l'annotation Spring originale

@Component @Controller @Service @Repository

Injection d'attribut
méthode d'injection originale du ressort

1.méthode set

2.constructeur

3.injection automatique

name: tom
age: 30
price: 23.5
sex: true
birth: 2021/11/28 12:12:12
array: 12,13,15,17
list: 李四,lisi,tom
map: "{&#39;aa&#39;:30,&#39;bb&#39;:&#39;lisi&#39;}" # 注入map使用json格式  取值的个数#{${map}}

对象的注入

object:
  name: lisi
  age: 20
  birth: 2021/11/24

@Controller
@RequestMapping("/inject2")
@ConfigurationProperties("object")
public class InjectController2 {

    private String name;
    private Integer age;
    private Date birth;

   	public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    }
    @RequestMapping("/inject")
    @ResponseBody
    public String inject(){
        System.out.println(name);
        System.out.println(age);
        System.out.println(birth);
        return  "ok";
    }
}

注意：添加一下依赖，可以再写yaml文件时提示,消除红色的警告提示。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

springBoot整合JSP

引入依赖

<!--        标准标签库-->
<dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<!--        让springboot内置的tomcat具有解析jsp的能力-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

配置视图解析器

spring:
  mvc:
    view:
      prefix: /
      suffix: .jsp

设置不重启项目刷新jsp页面

server:
  servlet:
    jsp:
      init-parameters:
        development: true  # 修改jsp页面无需重新启动项目