SpringBoot和数据库打交道:原生jdbc,整合Druid数据源,整合mybatis,整合JPA

原生jdbc

使用

需要导入的依赖
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

然后再编写配置文件就行了
默认是用org.apache.tomcat.jdbc.pool.DataSource作为数据源
数据源的相关配置都在DataSourceProperties里面
spring:
  datasource:
    username: root
    password: 123
    url: jdbc:mysql://192.168.31.22:3307/jdbc
    driver-class-name: com.mysql.jdbc.Driver

编写测试
@Autowired
DataSource dataSource;
@Test
public void contextLoads() throws SQLException
{
    //org.apache.tomcat.jdbc.pool.DataSource
    System.out.println("类型是:"+dataSource.getClass());

    Connection connection = dataSource.getConnection();
    //ProxyConnection[PooledConnection[com.mysql.jdbc.JDBC4Connection@295bf2a]]
    System.out.println("连接是:"+connection);
    connection.close();
}

原理

主要是参考org.springframework.boot.autoconfigure.jdbc里面的代码

DataSourceConfiguration

其中的DataSourceConfiguration根据配置创建数据源
默认是使用Tomcat连接池,
可以使用spring.datasource.type来指定自定义的数据源类型
springboot支持:
	org.apache.tomcat.jdbc.pool.DataSource
	com.zaxxer.hikari.HikariDataSource
	org.apache.commons.dbcp.BasicDataSource
	org.apache.commons.dbcp2.BasicDataSource

还可以自定义数据源类型
/**
 * Generic DataSource configuration.
 */
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type")
static class Generic {

	@Bean
	public DataSource dataSource(DataSourceProperties properties) {
		//使用DataSourceBuilder创建数据源，利用反射创建响应type的数据源，
		//并且绑定相关属性
		return properties.initializeDataSourceBuilder().build();
	}
}

initializeDataSourceBuilder()方法
/**
 * Initialize a {@link DataSourceBuilder} with the state of this instance.
 * @return a {@link DataSourceBuilder} initialized with the customizations defined on
 * this instance
 */
public DataSourceBuilder initializeDataSourceBuilder() {
	return DataSourceBuilder.create(getClassLoader()).type(getType())
			.driverClassName(determineDriverClassName()).url(determineUrl())
			.username(determineUsername()).password(determinePassword());
}
build()方法
public DataSource build() {
	Class<? extends DataSource> type = getType();
	DataSource result = BeanUtils.instantiate(type);
	maybeGetDriverClassName();
	bind(result);
	return result;
}

DataSourceAutoConfiguration

@Bean
@ConditionalOnMissingBean
public DataSourceInitializer dataSourceInitializer(DataSourceProperties properties,
		ApplicationContext applicationContext) {
	return new DataSourceInitializer(properties, applicationContext);
}
这个类给容器里面添加了一个DataSourceInitializer组件
class DataSourceInitializer implements ApplicationListener<DataSourceInitializedEvent>
它是一个容器监听器,
作用:
	runSchemaScripts();运行建表语句
	runDataScripts()运行插入数据的sql语句
如何使用:
	只需要将文件命名为：schema‐*.sql、data‐*.sql
		默认规则：schema.sql，schema‐all.sql；
	如果想指定文件,可以像下面指定文件
		spring:
		  datasource:
		    schema:
		     - classpath:department.sql
		     - classpath:employee.sql

JdbcTemplateAutoConfiguration

在JdbcTemplateAutoConfiguration里面还自动注入了JdbcTemplate
如果需要使用JdbcTemplate来操作数据库,
直接自动注入就可以使用了
    @Autowired
    JdbcTemplate jdbcTemplate;

整合Druid数据源

先引入数据源
	<!--引入druid数据源-->
	<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
	<dependency>
	   <groupId>com.alibaba</groupId>
	   <artifactId>druid</artifactId>
	   <version>1.1.8</version>
	</dependency>
在配置数据源类型
spring:
  datasource:
    username: root
    password: 123
    url: jdbc:mysql://192.168.31.22:3307/jdbc
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
这样就将druid整合进来了

但是druid数据源有很多属性可以配置的,直接写在配置文件里面无法生效
可以看出,下面的额外的属性配置,颜色都不一样了,
默认上面的username,password等等都是和DataSourceProperties这个类
进行绑定的,但是现在这个DataSourceProperties类没有下面的这些属性
所以下面的属性设置是无法生效的

所以还需要自己额外写多一个配置类
package com.jane.springboot_jdbc.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

/**
 * @author jane
 * @create 2021-02-16 1:31
 */
@Configuration
public class DruidConfig
{
    //先不适用它自己的利用反射来创建数据源,而是自己创建数据源
    //然后使用@ConfigurationProperties来绑定前缀是spring.datasource的属性设置
    //DruidDataSource里面的属性刚好和后面的设置对应得上
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid()
    {
        return new DruidDataSource();
    }
}

配置Druid的监控

package com.jane.springboot_jdbc.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @author jane
 * @create 2021-02-16 1:31
 */
@Configuration
public class DruidConfig
{
    //先不适用它自己的利用反射来创建数据源,而是自己创建数据源
    //然后使用@ConfigurationProperties来绑定前缀是spring.datasource的属性设置
    //DruidDataSource里面的属性刚好和后面的设置对应得上
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid()
    {
        return new DruidDataSource();
    }

    //配置druid的监控
    //1.需要配置一个管理后台的servlet
    //2.还需要配置一个监控的filter
    @Bean
    public ServletRegistrationBean statViewServlet()
    {
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        HashMap<String, String> initParams = new HashMap<>();
        //下面的属性在StatViewServlet 的父类 ResourceServlet里面
        initParams.put("loginUsername","admin");//登录用户名
        initParams.put("loginPassword","123");//登录密码
        initParams.put("allow","");//默认就是允许所有访问
        initParams.put("deny","192.168.15.21");//不允许谁访问

        bean.setInitParameters(initParams);
        return bean;
    }
    @Bean
    public FilterRegistrationBean webStatFilter()
    {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String,String> initParams = new HashMap<>();
        //将这些资源和请求排除
        initParams.put("exclusions","*.js,*.css,/druid/*");

        bean.setInitParameters(initParams);
        //拦截什么路径
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}

然后就可以进入监控页面了
请求http://localhost:8080/druid

整合mybatis

导入依赖
<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-jdbc</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <!--整合mybatis主要是引入多了这个依赖-->
   <dependency>
       <groupId>org.mybatis.spring.boot</groupId>
       <artifactId>mybatis-spring-boot-starter</artifactId>
       <version>2.1.4</version>
   </dependency>

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

然后就是像上面那样配置数据源的东西
先导入druid,然后配置数据源
然后给数据库创建表,创建表对应的JavaBean

注解方式

然后编写对应的mapper

package com.jane.mybatis.mapper;

import com.jane.mybatis.bean.Department;
import org.apache.ibatis.annotations.*;

/**
 * @author jane
 * @create 2021-02-18 19:13
 */
//指定这是一个操作数据库的mapper
@Mapper
public interface DepartmentMapper {

    @Select("select * from department where id=#{id}")
    public Department getDeptById(Integer id);

    @Delete("delete from department where id=#{id}")
    public int deleteDeptById(Integer id);

    //插入后将主键返回
    @Options(useGeneratedKeys = true,keyProperty = "id")
    @Insert("insert into department(department_name) values(#{departmentName})")
    public int insertDept(Department department);

    @Update("update department set department_name=#{departmentName} where id=#{id}")
    public int updateDept(Department department);
}

所有的配置原理都在MybatisAutoConfiguration里面能找到

如果需要自定义MyBatis的配置规则；给容器中添加一个ConfigurationCustomizer；

package com.jane.mybatis.config;

import org.apache.ibatis.session.Configuration;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.springframework.context.annotation.Bean;

/**
 * @author jane
 * @create 2021-02-28 19:53
 */
@org.springframework.context.annotation.Configuration
public class MybatisConfig
{
    @Bean
    public ConfigurationCustomizer configurationCustomizer()
    {
        return new ConfigurationCustomizer()
        {
            @Override
            public void customize(Configuration configuration)
            {
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }
}

还可以使用MapperScan来批量扫描所有的mapper接口
package com.jane.mybatis.config;

import org.apache.ibatis.session.Configuration;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.springframework.context.annotation.Bean;

@MapperScan(value ="com.jane.mybatis.mapper")
@org.springframework.context.annotation.Configuration
public class MybatisConfig
{
}

配置文件方式

先在资源文件里面编写好这些文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
</configuration>

<?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.jane.mybatis.mapper.EmployeeMapper">
   <!--    public Employee getEmpById(Integer id);

    public void insertEmp(Employee employee);-->
    <select id="getEmpById" resultType="com.jane.mybatis.bean.Employee">
        SELECT * FROM employee WHERE id=#{id}
    </select>

    <insert id="insertEmp">
        INSERT INTO employee(lastName,email,gender,d_id) VALUES (#{lastName},#{email},#{gender},#{dId})
    </insert>
</mapper>

然后再在全局配置文件里面编写
mybatis:
  # 指定全局配置文件位置
  config-location: classpath:mybatis/mybatis-config.xml
  # 指定sql映射文件位置
  mapper-locations: classpath:mybatis/mapper/*.xml

整合JPA

简介

SpringData特点
SpringData为我们提供使用统一的API来对数据访问层进行操作；这主要是Spring Data
Commons项目来实现的。Spring Data Commons让我们在使用关系型或者非关系型数据访问
技术时都基于Spring提供的统一标准，标准包含了CRUD（创建、获取、更新、删除）、查询、
排序和分页的相关操作。

统一的Repository接口
Repository<T, ID extends Serializable>：统一接口
RevisionRepository<T, ID extends Serializable, N extends Number & Comparable<N>>：基于乐观锁机制
CrudRepository<T, ID extends Serializable>：基本CRUD操作
PagingAndSortingRepository<T, ID extends Serializable>：基本CRUD及分页

先导入这些模块

jpa也是基于:ORM（Object Relational Mapping)的,所以
首先我们编写一个实体类（bean）和数据表进行映射，并且配置好映射关系

package com.jane.jpa.entity;

import javax.persistence.*;


//使用JPA注解配置映射关系
@Entity //告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是类名小写；
public class User
{

    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private Integer id;

    @Column(name = "last_name", length = 50) //这是和数据表对应的一个列
    private String lastName;

    @Column //省略默认列名就是属性名
    private String email;

    public Integer getId()
    {
        return id;
    }

    public void setId(Integer id)
    {
        this.id = id;
    }

    public String getLastName()
    {
        return lastName;
    }

    public void setLastName(String lastName)
    {
        this.lastName = lastName;
    }

    public String getEmail()
    {
        return email;
    }

    public void setEmail(String email)
    {
        this.email = email;
    }
}

然后编写一个Dao接口来操作实体类对应的数据表（SpringData叫Repository）

package com.jane.jpa.repository;

import com.jane.jpa.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

//继承JpaRepository来完成对数据库的操作
//两个泛型,第一个写的是要操作的实体类,第二个是主键的类型
public interface UserRepository extends JpaRepository<User, Integer>
{
}

然后在配置文件里面配置一些东西就能使用了
spring:
	jpa:
		hibernate:
		# 更新或者创建数据表结构
		ddl‐auto: update
		# 控制台显示SQL
		show‐sql: true