Spring boot连接mysql数据库启动说到数据库配置，我们最开始想象的也就是JDBC连接。使用配置文件上配置文件这样写会报错：无法访问org.springframework.dao.DataAccessException其实，一个Mevan不可以在项目中直接加jar包。一定要通过Mevan仓库来加。你可以创建一个假的文件包也可以从网上找依赖资源【笔者刚刚踩过的坑】上面是一些艰辛的历程，下面是总结

119 阅读 0 评论 79 点赞

我是靠谱客的博主平常歌曲，最近开发中收集的这篇文章主要介绍Spring boot连接mysql数据库启动说到数据库配置，我们最开始想象的也就是JDBC连接。使用配置文件上配置文件这样写会报错：无法访问org.springframework.dao.DataAccessException其实，一个Mevan不可以在项目中直接加jar包。一定要通过Mevan仓库来加。你可以创建一个假的文件包也可以从网上找依赖资源【笔者刚刚踩过的坑】上面是一些艰辛的历程，下面是总结，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

说到数据库配置，我们最开始想象的也就是JDBC连接。

1、首先，我们得准备mysql的驱动jar包

Spring boot连接mysql数据库启动

2、得有数据库

Spring boot连接mysql数据库启动

3、使用JDBC连接mysql数据库demo

    //JDBC驱动名
                String JDBC_DRIVER = "com.mysql.jdbc.Driver";
                //数据库URL：这里的mysql2020是数据库名称
                String JDBC_URL = "jdbc:mysql://localhost:3306/mysql2020?useSSL=false&serverTimezone=UTC";
                //数据库的用户名与密码
                String USER = "root";
                String PASS = "123456";
                //通过DriverManager类获得该连接对象才能访问数据库
                Connection connection = null;
                //通过Connection获得该结果对象用于执行静态的SQL语句
                Statement statement = null;
                try {
                        //注册JDBC驱动
                        Class.forName(JDBC_DRIVER);
                        //数据库的连接：通过DriverManager类的getConnection方法，传入三个参数：数据库URL、用户名、用户密码，实例化connection对象
                        connection = DriverManager.getConnection(JDBC_URL,USER,PASS);
                        //实例化statement对象
                        statement = (Statement) connection.createStatement();
                        //定义数据库查询语句：查询ceshi表中的uuid、Address两列数据
                        String sql = "SELECT uuid,Address FROM ceshi";
                        //执行查询语句
                        ResultSet rSet = statement.executeQuery(sql);
                        //展开查询到的数据
                        while(rSet.next()) {
                                //这里getString()方法中的参数对应的是数据库表中的列名
                                String get_name = rSet.getString("uuid");
                                String get_sex = rSet.getString("Address");
                                //输出数据
                                System.out.println("主键:"+get_name);
                                System.out.print("地址:"+get_sex);
                        }
                        //依次关闭对象
                        rSet.close();
                        statement.close();
                        connection.close();
                } catch (Exception e) {
                        e.printStackTrace();
                }

4、演示

Spring boot连接mysql数据库启动

使用配置文件

既然要使用配置文件，那肯定得做那种启动项目的了。
这里咱们先参照《Spring Boot的启动与调用》
再，做一下拓展。

1、在开发过程中最重要的就是单元测试了
【配置文件】在pom.xml包中添加下面的依赖

     <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-test</artifactId>
                    <scope>test</scope>
    </dependency>

　　
【开发测试类】

在测试类的头部添加：
@RunWith(SpringRunner.class)
@SpringBootTest注解，
在测试方法的顶端添加@Test即可，最后在方法上点击右键run就可以运行。

　
demo

    package redant;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.test.context.SpringBootTest;
    @SpringBootTest
    public class FrozenWebApplication {
            public static void main(String[] args) {
                    SpringApplication.run(FrozenWebApplication.class, args);
            }
    }

    package mysqlt;
    import org.junit.Test;
    import java.util.Date;
    public class SpringbootTestDemo {
            @Test
            public void springboottestFroze(){
                    for (int i = 0; i < 3; i++) {
                            Date date = new Date();
                            System.out.println(date.getTime());
                    }
            }
    }

演示demo

Spring boot连接mysql数据库启动

　【PS】
spring-boot-starter-test提供很多基础方法，包括增加了对Controller层测试的支持。
2、集成测试
　　
　　整体开发完成之后进入集成测试，spring boot项目的启动入口在 Application类中，直接运行run方法就可以启动项目，但是在调试的过程中我们肯定需要不断的去调试代码，如果每修改一次代码就需要手动重启一次服务就很麻烦，spring boot非常贴心的给出了热部署的支持，很方便在web项目中调试使用。
　pom需要添加以下的配置：

        <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools<http://www.yigouyule2.cn/ /artifactId>
                <optional>true</optional>
        </dependency>

　　　　
　　添加以上配置后，项目就支持了热部署，非常方便集成测试。
　　
　　3、项目上线
　　一般分为三种；一种是打包成jar包直接执行，另一种是打包成war包放到tomcat服务器下，还有就是直接链接项目文件。
　　A、打成jar包
　　如果你使用的是maven来管理项目，执行以下命令既可以
　　cd 项目跟目录（和pom.xml同级）
　　mvn clean package
　　 或者执行下面的命令，排除测试代码后进行打包
　　mvn clean package -Dmaven.test.skip=true
　　打包完成后jar包会生成到target目录下，命名一般是项目名+版本号.jar　
　　启动jar包命令
　　java -jar target/spring-boot-scheduler-1.0.0.jar　
　　这种方式，只要控制台关闭，服务就不能访问了。下面我们使用在后台运行的方式来启动:
　　nohup java -jar target/spring-boot-scheduler-1.0.0.jar &　
　　也可以在启动的时候选择读取不同的配置文件　
　　java -jar app.jar --spring.profiles.active=dev　
　　gradle　
　　如果使用的是gradle,使用下面命令打包　
　　gradle build　
　　java -jar build/libs/mymodule-0.0.1-SNAPSHOT.jar　
　　打成war包
　　打成war包一般可以分两种方式来实现，第一种可以通过eclipse这种开发工具来导出war包，另外一种是使用命令来完成，这里主要介绍后一种
　　1、maven项目，修改pom包将<packaging>jar</packaging>
　　　　改为
　　　　<packaging>war</packaging>
　　2、打包时排除tomcat

                <dependency>
                            <groupId>org.springframework.boot</groupId>
                            <artifactId>spring-boot-starter-web</artifactId>
                </dependency>
                <dependency>
                            <groupId>org.springframework.boot</groupId>
                            <artifactId>spring-boot-starter-tomcat</artifactId>
                            <scope>provided</scope>
                </dependency>

　　在这里将scope属性设置为provided，这样在最终形成的WAR中不会包含这个JAR包，因为Tomcat或Jetty等服务器在运行时将会提供相关的API类。
　　
这里笔者又想拓宽一下知识面，谈一谈Spring Boot的启动器Starter

《Spring Boot的启动器Starter详解》

上配置文件

不过在此之前，我还要拓展一下知识面对于org.apache.commons.dbcp.BasicDataSource的配置认知
Spring在第三方依赖中包含了两个数据源的实现类包，一个是Apache的DBCP，另一个是C3P0。使用任意一个都可以配置。
①DBCP数据源
DBCP类包在commons-dbcp.jar，DBCP是一个依赖 Jakarta commons-pool对象池机制的数据库连接池，所以在类路径下还必须包括commons-pool.jar。下面是使用DBCP配置MySql数据源的配置片断：

Spring boot连接mysql数据库启动
xml 代码

<!-- 定义一个使用DBCP实现的数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
      destroy-method="close"
      p:driverClassName="com.mysql.jdbc.Driver"
      p:url="jdbc:mysql://127.0.0.1:3306/mysql2020"
      p:username="root"
      p:password="123456"/>

BasicDataSource提供了close()方法关闭数据源，所以必须设定destroy-method=”close”属性，以便Spring容器关闭时，数据源能够正常关闭。
此外其还有以下属性：
defaultAutoCommit：设置从数据源中返回的连接是否采用自动提交机制，默认值为 true；
defaultReadOnly：设置数据源是否仅能执行只读操作，默认值为 false；
maxActive：最大连接数据库连接数，设置为0时，表示没有限制；
maxIdle：最大等待连接中的数量，设置为0时，表示没有限制；
maxWait：最大等待秒数，单位为毫秒，超过时间会报出错误信息；
validationQuery：用于验证连接是否成功的查询SQL语句，SQL语句必须至少要返回一行数据，如你可以简单地设置为：“select count(*) from user”；
removeAbandoned：是否自我中断，默认是 false ；
removeAbandonedTimeout：几秒后数据连接会自动断开，在removeAbandoned为true，提供该值；
logAbandoned：是否记录中断事件，默认为 false；
②C3P0数据源
C3P0是一个开放源代码的JDBC数据源实现项目，他在Lib目录中与Hibernate一起发布，C3P0类包位于c3p0-0.9.0.4.jar。
知识是无限的嘛，这里只测试一个就好了。这个就不写了！总之C3P0配置属性更多，更好！

再次拓展一下知识面对于使用JdbcTemplate简化JDBC操作实现数据库操作
Spring JDBC框架由4个部分组成，即core、datasource、object、support。
org.springframework.jdbc.core包由JdbcTemplate类以及相关的回调接口（callback interface）和类组成。
org.springframework.jdbc.datasource包由一些用来简化DataSource访问的工具类，以及各种DataSource接口的简单实现(主要用于单元测试以及在J2EE容器之外使用JDBC)组成。工具类提供了一些静态方法，诸如通过JNDI获取数据连接以及在必要的情况下关闭这些连接。它支持绑定线程的连接，比如被用于DataSourceTransactionManager的连接。
org.springframework.jdbc.object包由封装了查询、更新以及存储过程的类组成，这些类的对象都是线程安全并且可重复使用的。它们类似于JDO，与JDO的不同之处在于查询结果与数据库是“断开连接”的。它们是在org.springframework.jdbc.core包的基础上对JDBC更高层次的抽象。
org.springframework.jdbc.support包提供了一些SQLException的转换类以及相关的工具类

据说我们在src下新建applicationContext.xml内容如下：
　

         <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                     xmlns:p="http://www.springframework.org/schema/p"
                     xmlns:context="http://www.springframework.org/schema/context"
                    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
                <!-- 扫描类包， 将标注Spring注解的类自动转化为Bean，
                同时完成Bean的注入 -->
                <context:component-scan base-package="mysqlt"/>
                <!-- 定义一个使用DBCP实现的数据源 -->
                <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
                            destroy-method="close"
                            p:driverClassName="com.mysql.jdbc.Driver"
                            p:url="jdbc:mysql://127.0.0.1:3306/mysql2020"
                            p:username="root"
                            p:password="123456"/>
                <!-- 定义jdbc模板Bean -->
                <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
                            p:dataSource-ref="dataSource"/>
        </beans>

【注意】

@Autowired
private JdbcTemplate jdbcTemplate;

这样写会报错：无法访问org.springframework.dao.DataAccessException

你需要加下面的依赖，这是笔者刚刚踩过的坑。

 <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-tx</artifactId>
                 <version>3.1.0.RELEASE</version>
 </dependency>

其实，一个Mevan不可以在项目中直接加jar包。一定要通过Mevan仓库来加。你可以创建一个假的文件包也可以从网上找依赖资源【笔者刚刚踩过的坑】

也就是说，必须以依赖的形式添加驱动、jdbc、pool

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
        <version>2.2.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.4</version>
    </dependency>
    <dependency>
        <groupId>commons-pool</groupId>
        <artifactId>commons-pool</artifactId>
        <version>1.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.38</version>
    </dependency>

上面是一些艰辛的历程，下面是总结

【demo】
Spring boot连接mysql数据库启动

1、DemoApplication启动类

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {

        public static void main(String[] args) {
                SpringApplication.run(DemoApplication.class, args);
        }

}

2、application.properties配置文件

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mysql2020
spring.datasource.username=root
spring.datasource.password=123456

3、application.yml配置文件

server:
    port: 8089
    servlet:
        context-path: /frozen
http:
    #最大连接数
    maxTotal: 100
    #并发数
    defaultMaxPerroute: 30
    #创建连接的最长时间
    connectTimeout: 1000
    #从连接池中获取到连接的最长时间
    connectionRequestTimeout: 500
    #数据传输的最长时间
    socketTimeout: 10000
    #提交请求前测试连接是否可用
    staleConnectionCheckEnabled: true

4、applicationContext.xml配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xmlns:p="http://www.springframework.org/schema/p"
                 xmlns:context="http://www.springframework.org/schema/context"
                 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
            <!-- 扫描类包， 将标注Spring注解的类自动转化为Bean，同时完成Bean的注入 -->
         <context:component-scan base-package="com.example.demo"/>
            <!-- 定义一个使用DBCP实现的数据源 -->
            <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
                        destroy-method="close"
                        p:driverClassName="com.mysql.jdbc.Driver"
                        p:url="jdbc:mysql://127.0.0.1:3306/mysql2020/"
                        p:username="root"
                        p:password="123456"/>
            <!-- 定义jdbc模板Bean -->
            <!-- 配置 Spirng 的 JdbcTemplate -->
            <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                    <property name="dataSource" ref="dataSource"></property>
            </bean>
    </beans>

5、SpringMysqlConnec测试类

    package com.example.demo;

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import java.util.List;
    @RestController
    @RequestMapping("/redant")
    public class SpringMysqlConnect {

            @Autowired
            JdbcTemplate jdbcTemplate;
            @GetMapping("/20200423")
            public List queryMysqlTest(){
                    String sql = "select * from ceshi";
                    List<?> lst = jdbcTemplate.queryForList(sql);
                 System.out.println("共有" + lst.size() +"个");
                    /*for (int i = 0; i < lst.size(); i++) {
                            System.out.println(lst.get(i));
                    }*/
                    return lst;
            }
    }

Spring boot连接mysql数据库启动