Printemps 整合 JDBC 、 Druid 、 MyBatis

Printemps 整合 JDBC 、 Druid 、 MyBatis

1. Expliquez comment rédiger un site Web

1.1 Site Web

1. Face avant

• Modèle: écrit par d'autres, nous le changeons en ce dont nous avons besoin
• Cadre et composants: combinez et épissez manuellement par vous-même! BootStarp, Layui, interface utilisateur sémantique
  • Système de grille
  • Barre de navigation
  • Barre latérale
  • Forme

2. Concevoir la base de données

3. ingénierie indépendante, opération automatique frontale

4. Amarrage de l'interface de données: json, objet tout en un

5. Test de débogage de l'articulation front-end et back-end

1.2 Exigences

1. Il existe un ensemble de modèles d'arrière-plan avec lesquels vous êtes familier: travail nécessaire (x-admin)
2. Interface frontale: au moins, vous pouvez combiner une page Web (index, à propos, blog, article, utilisateur) via le framework front-end
3. Laissez votre propre site Web fonctionner indépendamment

2. Intégrez JDBC

Introduction à SpringData

Pour la couche d'accès aux données, qu'il s'agisse de SQL (base de données relationnelle) ou NOSQL (base de données non relationnelle), la couche inférieure de Spring Boot utilise Spring Data pour un traitement unifié.

La couche inférieure de Spring Boot utilise Spring Data pour traiter de manière uniforme diverses bases de données. Spring Data est également un projet bien connu de Spring avec le même nom que Spring Boot et Spring Cloud.

Site officiel de Sping Data: https://spring.io/projects/spring-data

Lanceurs liés à la base de données: vous pouvez vous référer aux documents officiels:

https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/reference/htmlsingle/#using-boot-starter

2.1 Créer une source de données de test de projet de test

1. Je vais créer un nouveau projet à tester: springboot-04-data; introduire les modules correspondants (web, jdbc, mysql)!

2. Une fois le projet construit, il a été découvert que les lanceurs suivants étaient automatiquement importés pour nous:

        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

3. Ecrivez un fichier de configuration yaml pour vous connecter à la base de données;

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver

4. Après avoir configuré ces choses, nous pouvons les utiliser directement, car SpringBoot a automatiquement configuré pour nous par défaut; allez à la classe de test pour tester

@SpringBootTest
class Springboot04DataApplicationTests {
    
    

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
    
    
        //查看以下默认的数据源 class com.zaxxer.hikari.HikariDataSource
        System.out.println(dataSource.getClass());

        //获得数据库连接
        Connection connection = dataSource.getConnection();
        //HikariProxyConnection@1765865093 wrapping com.mysql.cj.jdbc.ConnectionImpl@47b179d7
        System.out.println(connection);

        //关闭
        connection.close();
    }

}

Résultat: nous pouvons voir que la source de données qu'il a configurée pour nous par défaut est: class com.zaxxer.hikari.HikariDataSource, nous ne l'avons pas configurée manuellement

Cherchons globalement et constatons que toutes les configurations automatiques de la source de données se trouvent dans: DataSourceAutoConfiguration file:

@Import(
    {
    
    Hikari.class, Tomcat.class, Dbcp2.class, Generic.class, DataSourceJmxConfiguration.class}
)
protected static class PooledDataSourceConfiguration {
    
    
    protected PooledDataSourceConfiguration() {
    
    
    }
}

Les classes importées ici sont toutes sous la classe de configuration DataSourceConfiguration. On peut voir que Spring Boot 2.2.5 utilise HikariDataSource par défaut, tandis que les versions précédentes, telles que Spring Boot 1.5, utilisent org.apache.tomcat.jdbc.pool.DataSource comme la source de données par défaut.

HikariDataSource est connu comme la source de données la plus rapide de Java WEB, ce qui est plus excellent que les pools de connexions traditionnels tels que C3P0, DBCP, Tomcat jdbc, etc.

Vous pouvez utiliser spring.datasource.type pour spécifier un type de source de données personnalisé. La valeur est le nom complet de l'implémentation du pool de connexions à utiliser.

Nous n'introduirons pas la source de données.Avec la connexion de base de données, vous pouvez évidemment faire fonctionner la base de données avec CRUD. Mais nous devons d'abord comprendre un objet JdbcTemplate

2.2JDBCTemplate

1. Avec la source de données (com.zaxxer.hikari.HikariDataSource), vous pouvez ensuite obtenir la connexion à la base de données (java.sql.Connection) .Avec la connexion, vous pouvez utiliser des instructions JDBC natives pour faire fonctionner la base de données;

2. Même si vous n'utilisez pas de cadre d'exploitation de base de données tiers, tel que MyBatis, etc., Spring lui-même a créé un package léger pour JDBC natif, à savoir JdbcTemplate.

3. Toutes les méthodes CRUD des opérations de base de données se trouvent dans JdbcTemplate.

4. Spring Boot fournit non seulement une source de données par défaut, en même temps que le JdbcTemplate a été configuré par défaut et placé dans le conteneur, les programmeurs n'ont qu'à s'injecter pour utiliser

5. La configuration automatique de JdbcTemplate repose sur la classe JdbcTemplateConfiguration sous le package org.springframework.boot.autoconfigure.jdbc

JdbcTemplate fournit principalement les méthodes suivantes:

• La méthode execute: peut être utilisée pour exécuter n'importe quelle instruction SQL, généralement utilisée pour exécuter des instructions DDL;
• méthode de mise à jour et méthode batchUpdate: la méthode de mise à jour est utilisée pour exécuter des instructions telles que l'ajout, la modification et la suppression; la méthode batchUpdate est utilisée pour exécuter des instructions liées aux lots;
• méthode de requête et méthode queryForXXX: utilisées pour exécuter des instructions liées à la requête;
• méthode d'appel: utilisée pour exécuter des procédures stockées et des instructions liées aux fonctions.

2.3 Test

Ecrire un Controller, injecter jdbcTemplate et écrire des méthodes de test pour les tests d'accès;

@RestController
public class JDBCController {
    
    
    @Autowired
    JdbcTemplate jdbcTemplate;

    //查询数据库的所有信息
    //没有实体类，数据库中的东向西，怎么获取？Map
    @GetMapping("/userList")
    public List<Map<String,Object>> userList(){
    
    
        String sql = "select * from user";
        List<Map<String, Object>> list_maps = jdbcTemplate.queryForList(sql);
        return list_maps;
    }

    @GetMapping("addUser")
    public String addUser(){
    
    
        String sql = "insert into user(id,name,pwd)values(5,'小子','123456')";
        jdbcTemplate.update(sql);
        return "add-ok";
    }

    @GetMapping("/updateUser/{id}")
    public String updateUser(@PathVariable("id")int id){
    
    
        String sql = "update user set name=?,pwd=? where id="+id;

        //封装
        Object[] objects = new Object[2];
        objects[0] = "yong";
        objects[1] = "123456";
        jdbcTemplate.update(sql,objects);
        return "update-ok";
    }

    @GetMapping("/deleteUser/{id}")
    public String deleteUser(@PathVariable("id")int id){
    
    
        String sql = "delete from user where id="+id;
        jdbcTemplate.update(sql);
        return "delete-ok";
    }
}

Demande de test, le résultat est normal;

À ce stade, le fonctionnement de base de CURD est effectué à l'aide de JDBC.

3. Intégrez Druid

3.1 Introduction à Druid

Une grande partie du programme Java doit faire fonctionner la base de données, afin d'améliorer les performances lors de l'exploitation de la base de données, vous devez utiliser le pool de connexion à la base de données.

Druid est une implémentation de pool de connexion de base de données sur la plate-forme open source Alibaba, combinant les avantages de C3P0, DBCP et d'autres pools de bases de données, et ajoutant la surveillance des journaux.

Druid peut bien surveiller la connexion du pool de bases de données et l'exécution de SQL, et il est né pour être un pool de connexions de bases de données pour la surveillance.

Druid a déployé plus de 600 applications à Alibaba et a été rigoureusement testé dans un environnement de production à grande échelle pendant plus d'un an.

Spring Boot 2.0 et les versions ultérieures utilisent la source de données Hikari par défaut. On peut dire que Hikari et Driud sont les meilleures sources de données sur le Web Java actuel. Concentrons-nous sur la manière dont Spring Boot intègre les sources de données Druid et comment implémenter la surveillance de base de données.

Adresse Github: https://github.com/alibaba/druid/

3.2 Configurer la source de données

1. Ajoutez une dépendance de source de données Druid.

        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>

2. Changez de source de données, il a déjà été dit que Spring Boot 2.0 et supérieur utilisent la source de données com.zaxxer.hikari.HikariDataSource par défaut, mais la source de données peut être spécifiée par spring.datasource.type.

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

3. Une fois la source de données commutée, injectez le DataSource dans la classe de test, puis récupérez-le et la sortie vous indiquera si le commutateur a réussi ou non;

4. Le changement est réussi! Maintenant que le basculement est réussi, vous pouvez définir la taille d'initialisation de la connexion à la source de données, le nombre maximum de connexions, le temps d'attente, le nombre minimum de connexions et d'autres paramètres; vous pouvez afficher le code source

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

    #Spring Boot默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxWait: 60000
    timeBetweeEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters，start：监控统计、log4j:日志记录、wall:防御sql注入
    #如果运行时报错 java。Lang。ClassNotFoundException：org。apache.log4j.Priority
    #则导入log4j依赖即可，Maven地址：http://mvnrepository.com/artifact/log4j/log4j
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

5. Importez les dépendances de Log4j

        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

6. Les programmeurs doivent maintenant lier les paramètres dans le fichier de configuration globale pour DruidDataSource par eux-mêmes, puis les ajouter au conteneur, au lieu d'utiliser la génération automatique de Spring Boot; nous devons ajouter le composant DruidDataSource au conteneur par nous-mêmes, et lier les propriétés;

@Configuration
public class DruidConfig {
    
    

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
    
    
        return new DruidDataSource();
    }
}

7. Allez tester dans la classe de test, voyez si cela réussit!

3.3 Configurer la surveillance de la source de données Druid

La source de données Druid a la fonction de surveillance et fournit une interface Web que les utilisateurs peuvent afficher, comme lorsque le routeur est installé, d'autres fournissent également une page Web par défaut.

La première étape consiste donc à configurer la page de gestion back-end de Druid, comme le compte de connexion, le mot de passe, etc.; configurer la gestion back-end

DruidConfig

@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }

    //后台监控 web.xml
    //因为SpringBoot内置了servlet容器，所以没有web.xml 替代方法：ServletRegistrationBean
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        //后台需要有人登录，账号密码配置
        HashMap<String, String> initParameters = new HashMap<>();

        //增加配置
        initParameters.put("loginUsername","admin");//登录的key是固定的
        initParameters.put("loginPassword","123456");
        bean.setInitParameters(initParameters);//设置初始化参数

        //允许谁可以访问
        initParameters.put("allow","");//谁都可以访问

        //禁止谁能访问
        initParameters.put("shen","192.168.11.123");
        return bean;
    }
}

Après configuration, nous pouvons choisir de visiter: http: // localhost: 8080 / druid / login.html

3.4 Filtre de filtre de surveillance Web Druid

DruidConfig

    //filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
    
    
        FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>();
        bean.setFilter(new WebStatFilter());
        //可以过滤哪些请求呢？
        HashMap<String, String> initParameters = new HashMap<>();

        //这些请求不进行统计
        initParameters.put("exclusions","*.js,*.css,/druid/**");

        bean.setInitParameters(initParameters);
        return bean;
    }

En travail normal, vous pouvez le configurer en fonction de vos besoins, principalement pour la surveillance!

4. Intégrer le framework MyBatis

Document officiel: http://mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/

Adresse de l'entrepôt Maven: https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter/2.1.1

4.1 étapes

1. Importer un package
2. Fichier de configuration
3. configuration mybatis
4. Ecrire SQL
5. La couche métier appelle la couche DAO
6. Le contrôleur appelle la couche de service

4.2 essai

1. Importez les dépendances requises par MyBatis

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

2. Configurer les informations de connexion à la base de données (inchangées)

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

    #Spring Boot默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxWait: 60000
    timeBetweeEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters，start：监控统计、log4j:日志记录、wall:防御sql注入
    #如果运行时报错 java。Lang。ClassNotFoundException：org。apache.log4j.Priority
    #则导入log4j依赖即可，Maven地址：http://mvnrepository.com/artifact/log4j/log4j
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

3. Vérifiez si la base de données est correctement connectée!

@SpringBootTest
class Springboot05MybatisApplicationTests {
    
    

    @Autowired
    private DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
    
    
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }

}

4. Créez une classe d'entité et importez Lombok!

Department.java

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    private int id;
    private String name;
    private String pwd;
}

5. Créez le répertoire du mappeur et l'interface correspondante du mappeur

UserMapper

//这个注解表示了这是一个mybatis的mapper类
@Mapper
@Repository
public interface UserMapper {
    
    

    List<User> queryUserList();

    User queryUserById(int id);

    int addUser(User user);

    int updateUser(User user);

    int deleteUser(int id);
}

6. Configurer l'alias

application.yml

# 整合mybatis
mybatis:
  type-aliases-package: com.simpleteen.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml

7. Fichier de mappage Mapper correspondant

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.simpleteen.mapper.UserMapper">

    <select id="queryUserList" resultType="User">
        select * from user
    </select>

    <select id="selectUserById" resultType="User">
        select * from user where id = #{id}
    </select>

    <insert id="addUser" parameterType="User">
        insert into user(id,name,pwd) values (#{id},#{name},#{pwd})
    </insert>

    <update id="updateUser" parameterType="User">
        update user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from user where id =#{id}
    </delete>
</mapper>

8. Contrôleur à tester!

@RestController
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @GetMapping("/queryUserList")
    public List<User> queryUserList(){
        List<User> userList = userMapper.queryUserList();
        return userList;
    }

    @GetMapping("/addUser")
    public String addUser(){
        userMapper.addUser(new User(5,"小勇","123456"));
        return "ok";
    }

    @GetMapping("/updateUser")
    public String updateUser(){
        userMapper.updateUser(new User(5,"大勇","123456"));
        return "ok";
    }

    @GetMapping("deleteUser")
    public String deleteUser(){
        userMapper.deleteUser(5);
        return "ok";
    }
}

Commencez la visite du projet pour tester!