Spring 使用Druid数据源 整合 Mybatis步骤 (Maven项目)

githhub源码下载

1.pom文件中添加依赖包

---

  1)spring + junit4 测试

        <!-- junit test start-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.8.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- junit test end-->

2）数据库相关

        <!-- database start -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.18</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.39</version>
        </dependency>
        <!-- database end -->

---

2. 创建DruidDatasource数据源

---

   1)创建db.properties文件(在resources路径下)

##druid数据库连接池配置##
# MySql数据库连接信息
datasource.druid.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useSSL=false
# 根据url自动识别 这一项可配可不配,
# 如果不配置druid会根据url自动识别dbType,
# 然后选择相应的driverClassName(建议配置下)
datasource.druid.drvierClassName=com.mysql.jdbc.Driver
datasource.druid.userName=root
datasource.druid.password=root

# 初始化时建立物理连接的个数
# 初始化发生在显示调用init方法,或者第一次getConnection时
datasource.druid.initialSize=5
# 最小连接池数量
datasource.druid.minIdle=5
# 最大连接池数量
datasource.druid.maxActive=25
# 获取最大连接时最大等待时间,单位时毫秒
# 配置了maxWait之后,缺省启用公平锁，并发效率会有所下降
# 如果需要可以通过配置useUnfairLock属性为true使用非公平锁
datasource.druid.maxWait=5000
# 是否缓存preparedStatement,也就是PSCache
# PSCache对支持游标的数据库性能提升巨大,比如说oracle.
# 在mysql下建议关闭
datasource.druid.poolPreparedStatements=false
# 当poolPreparedStatements配置为true时,才可以使用
# 要启用PSCache,必须配置大于0,当大于0时,poolPreparedStatements自动触发修改为true。
# 在Druid中,不会存在Oracle下PSCache占用内存过多的问题
# 可以把这个数值配置大一些,比如说100
#datasource.druid.maxOpenPreparedStatements=100
# 用来检测连接是否有效的sql,要求是一个查询语句
# 如果validationQuery为null,testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
datasource.druid.validationQuery = SELECT 'x'
# 申请连接时执行validationQuery检测连接是否有效,做了这个配置会降低性能
# 开发时使用,生产环境建议关闭
# 默认值为true
datasource.druid.testOnBorrow=true
# 归还连接时执行validationQuery检测连接是否有效,做了这个配置会降低性能
# 默认值为false
datasource.druid.testOnReturn=false
# 建议配置为true,不影响性能,并且保证安全性.申请连接的时候检测
# 如果空闲时间大于timeBetweenEvictionRunsMillis
# 执行validationQuery检测连接是否有效
# 默认值为false
datasource.druid.testWhileIdle=true
# 1)Destroy线程会检测连接的间隔时间
# 2)testWhileIdle的判断依据
datasource.druid.timeBetweenEvictionRunsMillis=5000
#一个连接在池中最小生存的时间，单位是毫秒
datasource.druid.minEvictableIdleTimeMillis=300000

2) 创建DruidDataSourceConfig类

package com.roger.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:db.properties")
public class DruidDataSourceConfig {

    @Value("${datasource.druid.drvierClassName}")
    private String driveClassName;
    @Value("${datasource.druid.url}")
    private String url;
    @Value("${datasource.druid.userName}")
    private String userName;
    @Value("${datasource.druid.password}")
    private String password;
    @Value("${datasource.druid.initialSize}")
    private int initialSize;
    @Value("${datasource.druid.minIdle}")
    private int minIdle;
    @Value("${datasource.druid.maxActive}")
    private int maxActive;
    @Value("${datasource.druid.maxWait}")
    private long maxWait;
    @Value("${datasource.druid.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    @Value("${datasource.druid.validationQuery}")
    private String validationQuery;
    @Value("${datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${datasource.druid.testOnReturn}")
    private boolean testOnReturn;
    @Value("${datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${datasource.druid.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;
    @Value("${datasource.druid.minEvictableIdleTimeMillis}")
    private long minEvictableIdleTimeMillis;
    @Value("${datasource.druid.filters}")
    private String filters;

    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driveClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(userName);
        druidDataSource.setPassword(password);

        druidDataSource.setInitialSize(initialSize);

        druidDataSource.setMinIdle(minIdle);
        druidDataSource.setMaxActive(maxActive);
        druidDataSource.setMaxWait(maxWait);

        druidDataSource.setPoolPreparedStatements(poolPreparedStatements);

        druidDataSource.setValidationQuery(validationQuery);
        druidDataSource.setTestOnBorrow(testOnBorrow);
        druidDataSource.setTestOnReturn(testOnReturn);
        druidDataSource.setTestWhileIdle(testWhileIdle);
        druidDataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        druidDataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        return druidDataSource;
    }

}

3)创建junit测试类TestDruidDataSource 

package com.roger;

import com.roger.config.DruidDataSourceConfig;
import com.roger.config.MyBatisConfig;
import com.roger.config.SpringBeanConfig;
import com.roger.config.SpringTXConfig;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {DruidDataSourceConfig.class, MyBatisConfig.class, SpringTXConfig.class, SpringBeanConfig.class})
public class SpringBaseTestSuit {
}

package com.roger.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.roger.SpringBaseTestSuit;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

public class TestDruidDataSource extends SpringBaseTestSuit {

    @Autowired
    private DruidDataSource dataSource;

    @Test
    public void testInjectDruidDataSource() throws Exception{
        dataSource.getConnection();
        Assert.assertEquals(dataSource.getInitialSize(),dataSource.getCreateCount());
    }

}

---

3.创建SqlSessionFactory以及操作数据库的Mapper接口

---

1创建MyBatisConfig

package com.roger.config;

import com.roger.constant.SystemConstant;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.omg.SendingContext.RunTime;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import javax.sql.DataSource;
import java.io.IOException;

@Configuration
@Import(DruidDataSourceConfig.class)
public class MyBatisConfig {


    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) throws IOException {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        sqlSessionFactoryBean.setDataSource(dataSource);


        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();

        sqlSessionFactoryBean.setMapperLocations(resourcePatternResolver.getResources(SystemConstant.MAPPER_XML_PATH));

        sqlSessionFactoryBean.setTypeAliasesPackage(SystemConstant.TYPE_ALIASES_PACKAGE);

        return sqlSessionFactoryBean;
    }


    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();

        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        mapperScannerConfigurer.setBasePackage(SystemConstant.MAPPER_SCAN_BASE_PACKAGE);

        return  mapperScannerConfigurer;
    }

}

2.创建一个SystemConstant类

package com.roger.constant;

public class SystemConstant {

    public static final String TYPE_ALIASES_PACKAGE = "com.roger.entity";
    public static final String MAPPER_SCAN_BASE_PACKAGE = "com.roger.mapper";
    public static final String MAPPER_XML_PATH = "classpath:mapper/*Mapper.xml";
    public static final String COMPONENT_SCAN_PACKAGE = "com.roger";
}

3.创建实体类User和UserMapper接口

package com.roger.entity;

public class User {

    private int id;
    private String userName;
    private int age;
    private String phone;
    private String desc;

}

package com.roger.mapper;

import com.roger.entity.User;

import java.util.List;

public interface UserMapper {

    List<User> getUserList();
}

4)创建UserMappper.xml文件(在resources/mapper路径下)

<?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.roger.mapper.UserMapper">

    <select id="getUserList" resultType="User">
        SELECT id,username,age,phone,'desc' FROM user
    </select>

</mapper>

5.创建junit测试类TestUserMapper ( 要在父类 SpringBaseTestSuit 添加MyBatisConfig.class)

package com.roger.mapper;

import com.roger.SpringBaseTestSuit;
import com.roger.entity.User;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;

public class TestUserMapper extends SpringBaseTestSuit {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testGetUserList(){
       List<User> users = userMapper.getUserList();
       Assert.assertTrue(users.size() >= 0);
    }
}

---

4.添加事务

---

1) 创建JavaBean 配置Java类

package com.roger.config;

import com.roger.constant.SystemConstant;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(SystemConstant.COMPONENT_SCAN_PACKAGE)
public class SpringBeanConfig {
}

2)创建事务管理器 DataSourceTransactionManager

package com.roger.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
@Import(DruidDataSourceConfig.class)
@EnableTransactionManagement
public class SpringTXConfig {

    @Bean
    public DataSourceTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

}

3)创建Service接口及其实现类

package com.roger.service;

import com.roger.entity.User;

import java.util.List;

public interface UserService {

    List<User> getUserList();

    int insertUser(User user);
}

package com.roger.service.impl;

import com.roger.entity.User;
import com.roger.mapper.UserMapper;
import com.roger.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> getUserList() {
        return userMapper.getUserList();
    }

    @Transactional
    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }
}

4)创建测试类

package com.roger.service;

import com.roger.SpringBaseTestSuit;
import com.roger.entity.User;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

public class TestUserServiceImpl extends SpringBaseTestSuit {

    @Autowired
    private UserService userService;

    @Test
    public void testInsertUser(){
        User user  = new User();
        user.setAge(19);
        user.setPhone("16422455");
        user.setUserName("Mary");
        user.setDesc("Pretty");
        int count = userService.insertUser(user);
        Assert.assertTrue(count >= 0);
    }

}

---