Spring boot连接mysql数据库启动

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

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

2、得有数据库

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的启动与调用》 再，做一下拓展。

** 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

　【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数据源的配置片断：

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】

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