sharding-jdbc实现原理——分库分表代码实战

Sharding-JDBC简介

Sharding-JDBC是当当应用框架ddframe中,从关系型数据库模块dd-rdb中分离出来的数据库水平分片框架,实现透明化数据库分库分表访问。Sharding-JDBC是继dubbox和elastic-job之后,ddframe系列开源的第3个项目。

实现原理

前文已介绍了Sharding-JDBC是实现了JDBC协议的jar文件。基于JDBC协议的实现与基于MySQL等数据库协议实现的中间层略有差别。

无论使用哪种架构,核心逻辑均极为相似,除了协议实现层不同(JDBC或数据库协议),都会分为分片规则配置、SQL解析、SQL改写、SQL路由、SQL执行以及结果归并等模块。

Sharding-JDBC的整体架构图参见图1。

sharding-jdbc实现原理——分库分表代码实战_第1张图片

图1 Sharding-JDBC的整体架构图

分库分表实战

接下来,我们就利用sharding-jdbc进行数据库的分库分表操作。

1、创建数据库

首先我们创建相应的数据库

create database sharding_0;
create database sharding_1;

这样我们就创建了两个数据库sharding_0和sharding_1;

接下来我们在两个库中创建相应的数据表,在两个库中分别进行如下SQL:

SET FOREIGN_KEY_CHECKS=0;
 
-- ----------------------------
-- Table structure for t_student_00
-- ----------------------------
DROP TABLE IF EXISTS `t_student_00`;
CREATE TABLE `t_student_00` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `student_id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-- ----------------------------

-- Table structure for t_student_01
-- ----------------------------
DROP TABLE IF EXISTS `t_student_01`;
CREATE TABLE `t_student_01` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `student_id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Table structure for t_user_00
-- ----------------------------
DROP TABLE IF EXISTS `t_user_00`;
CREATE TABLE `t_user_00` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,

  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Table structure for t_user_01
-- ----------------------------
DROP TABLE IF EXISTS `t_user_01`;
CREATE TABLE `t_user_01` (

  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Table structure for t_user_02
-- ----------------------------
DROP TABLE IF EXISTS `t_user_02`;
CREATE TABLE `t_user_02` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

这样,我们的数据库就准备好了。

2、创建项目

接下来,我们就创建一个Maven项目,项目结构如下:

sharding-jdbc实现原理——分库分表代码实战_第2张图片

3、配置pom.xml

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  4.0.0  
  
  com.lyz  
  sharding-jdbc-mybatis  
  0.0.1-SNAPSHOT  
  jar  
  
  sharding-jdbc-mybatis  
  http://maven.apache.org  
  
   
        UTF-8  
        4.1.0.RELEASE
        3.2.4  
   
 
  
     
         
            junit  
            junit  
            4.10  
       
 
         
            com.dangdang  
            sharding-jdbc-core  
            1.0.0  
       
 
         
            org.springframework  
            spring-orm  
            ${spring.version}  
       
 
         
            commons-dbcp  
            commons-dbcp  
            1.4  
       
 
         
            org.mybatis  
            mybatis-spring  
            1.2.2  
       
 
         
            org.mybatis  
            mybatis  
            ${mybatis.version}  
       
 
  
         
            org.springframework  
            spring-expression  
            ${spring.version}  
       
 
         
            org.springframework  
            spring-aop  
            ${spring.version}  
       
 
         
            org.springframework  
            spring-beans  
            ${spring.version}  
       
 
         
            org.springframework  
            spring-context  
            ${spring.version}  
       
 
         
            org.springframework  
            spring-context-support  
            ${spring.version}  
       
 
         
            org.springframework  
            spring-test  
            ${spring.version}  
       
 
         
            org.springframework  
            spring-tx  
            ${spring.version}  
       
 
         
            mysql  
            mysql-connector-java  
            5.1.28  
       
 
         
            log4j  
            log4j  
            1.2.16  
       
 
         
            org.slf4j  
            slf4j-log4j12  
            1.7.5  
       
 
   
 
 

4、创建数据库映射类

这里,我们创建两个数据库映射类:User类和Student类。

4-1、User类

package com.lyz.sharding.entity;
 
import java.io.Serializable;
 
/**
 * 用户类
 * @author liuyazhuang
 *
 */
public class User implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private Integer id;
 
    private Integer userId;
 
    private String name;
 
    private Integer age;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public Integer getUserId() {
        return userId;
    }
 
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "User [id=" + id + ", userId=" + userId + ", name=" + name + ", age=" + age + "]";
    }
 
}

 

4-2、Student类

package com.lyz.sharding.entity;
 
import java.io.Serializable;
 
/**
 * 学生类
 * @author liuyazhuang
 *
 */
public class Student implements Serializable {
 
    private static final long serialVersionUID = 8920597824668331209L;
 
    private Integer id;
 
    private Integer studentId;
 
    private String name;
 
    private Integer age;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public Integer getStudentId() {
        return studentId;
    }
 
    public void setStudentId(Integer studentId) {
        this.studentId = studentId;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Student [id=" + id + ", studentId=" + studentId + ", name=" + name + ", age=" + age + "]";
    }
    
}

5、创建Mapper类
5-1、UserMapper类

package com.lyz.sharding.mapper;
 
import java.util.List;
import com.lyz.sharding.entity.User;  
  
  
/**
 * 处理用户的数据操作接口
 * @author liuyazhuang
 *
 */
public interface UserMapper {  
      
    Integer insert(User u);  
      
    List findAll();  
      
    List findByUserIds(List userIds);  
      
  
}  
5-2、StudentMapper类

package com.lyz.sharding.mapper;
 
import java.util.List;
import com.lyz.sharding.entity.Student;
 
/**
 * 处理学生的数据操作接口
 * @author liuyazhuang
 *
 */
public interface StudentMapper {  
      
    Integer insert(Student s);  
      
    List findAll();  
      
    List findByStudentIds(List studentIds);  
 
}  
6、创建service类
6-1、UserService类

package com.lyz.sharding.service;  
 
import java.util.List;
import com.lyz.sharding.entity.User;
 
/**
 * 处理用户的Service
 * @author liuyazhuang
 *
 */
public interface UserService {  
      
    public boolean insert(User u);  
      
    public List findAll();  
      
    public List findByUserIds(List ids);  
      
    public void transactionTestSucess();  
      
    public void transactionTestFailure() throws IllegalAccessException;  
 
}  
6-2、StudentService类

package com.lyz.sharding.service;
 
import com.lyz.sharding.entity.Student;
 
/**
 * 处理学生的service
 * @author liuyazhuang
 *
 */
public interface StudentService {  
 
    boolean insert(Student student);  
 
}  
7、创建service的实现类
7-1、UserServiceImpl类

package com.lyz.sharding.service.impl;
 import java.util.List;
 
import javax.annotation.Resource;
 
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.lyz.sharding.entity.Student;
import com.lyz.sharding.entity.User;
import com.lyz.sharding.mapper.StudentMapper;
import com.lyz.sharding.mapper.UserMapper;
import com.lyz.sharding.service.UserService; 
  
@Service  
@Transactional  
public class UserServiceImpl implements UserService {  
  
    @Resource  
    public UserMapper userMapper;  
      
    @Resource  
    public StudentMapper studentMapper;  
  
    public boolean insert(User u) {  
        return userMapper.insert(u) > 0 ? true :false;  
    }  
  
    public List findAll() {  
        return userMapper.findAll();  
    }  
  
    public List findByUserIds(List ids) {  
        return userMapper.findByUserIds(ids);  
    }  
  
    @Transactional(propagation=Propagation.REQUIRED)  
    public void transactionTestSucess() {  
        User u = new User();  
        u.setUserId(13);  
        u.setAge(25);  
        u.setName("war3 1.27");  
        userMapper.insert(u);  
          
        Student student = new Student();  
        student.setStudentId(21);  
        student.setAge(21);  
        student.setName("hehe");  
        studentMapper.insert(student);  
    }  
  
    @Transactional(propagation=Propagation.REQUIRED)  
    public void transactionTestFailure() throws IllegalAccessException {  
        User u = new User();  
        u.setUserId(13);  
        u.setAge(25);  
        u.setName("war3 1.27 good");  
        userMapper.insert(u);  
          
        Student student = new Student();  
        student.setStudentId(21);  
        student.setAge(21);  
        student.setName("hehe1");  
        studentMapper.insert(student);  
        throw new IllegalAccessException();  
    }  
      
}  
7-2、StudentServiceImpl类

package com.lyz.sharding.service.impl;
import javax.annotation.Resource;
 
import org.springframework.stereotype.Service;
 
import com.lyz.sharding.entity.Student;
import com.lyz.sharding.mapper.StudentMapper;
import com.lyz.sharding.service.StudentService;
  
@Service  
public class StudentServiceImpl implements StudentService{  
      
    @Resource  
    public StudentMapper studentMapper;  
  
    public boolean insert(Student student) {  
        return studentMapper.insert(student) > 0 ? true : false;  
    }  
  
}  
8、创建分库逻辑
8-1、User分库逻辑UserSingleKeyDatabaseShardingAlgorithm类

package com.lyz.sharding.algorithm;  
 
import java.util.Collection;  
import java.util.LinkedHashSet;  
 
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;  
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;  
import com.google.common.collect.Range;  
 
/** 
 * user表分库的逻辑函数 
 * @author liuyazhuang
 * 
 */  
public class UserSingleKeyDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm{  
 
    /** 
     * sql 中关键字 匹配符为 =的时候,表的路由函数 
     */  
    public String doEqualSharding(Collection availableTargetNames, ShardingValue shardingValue) {  
        for (String each : availableTargetNames) {  
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {  
                return each;  
            }  
        }  
        throw new IllegalArgumentException();  
    }  
 
    /** 
     * sql 中关键字 匹配符为 in 的时候,表的路由函数 
     */  
    public Collection doInSharding(Collection availableTargetNames, ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(availableTargetNames.size());  
        for (Integer value : shardingValue.getValues()) {  
            for (String tableName : availableTargetNames) {  
                if (tableName.endsWith(value % 2 + "")) {  
                    result.add(tableName);  
                }  
            }  
        }  
        return result;  
    }  
 
    /** 
     * sql 中关键字 匹配符为 between的时候,表的路由函数 
     */  
    public Collection doBetweenSharding(Collection availableTargetNames,  
            ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(availableTargetNames.size());  
        Range range = (Range) shardingValue.getValueRange();  
        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {  
            for (String each : availableTargetNames) {  
                if (each.endsWith(i % 2 + "")) {  
                    result.add(each);  
                }  
            }  
        }  
        return result;  
    }  
 
}  
8-2、Student分库逻辑StudentSingleKeyDatabaseShardingAlgorithm

package com.lyz.sharding.algorithm;
import java.util.Collection;  
import java.util.LinkedHashSet;  
  
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;  
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;  
import com.google.common.collect.Range;  
  
/** 
 * user表分库的逻辑函数 
 * @author liuyazhuang 
 * 
 */  
public class StudentSingleKeyDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm{  
  
    /** 
     * sql 中关键字 匹配符为 =的时候,表的路由函数 
     */  
    @Override
    public String doEqualSharding(Collection availableTargetNames, ShardingValue shardingValue) {  
        for (String each : availableTargetNames) {  
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {  
                return each;  
            }  
        }  
        throw new IllegalArgumentException();  
    }  
  
    /** 
     * sql 中关键字 匹配符为 in 的时候,表的路由函数 
     */
    @Override
    public Collection doInSharding(Collection availableTargetNames, ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(availableTargetNames.size());  
        for (Integer value : shardingValue.getValues()) {  
            for (String tableName : availableTargetNames) {  
                if (tableName.endsWith(value % 2 + "")) {  
                    result.add(tableName);  
                }  
            }  
        }  
        return result;  
    }  
  
    /** 
     * sql 中关键字 匹配符为 between的时候,表的路由函数 
     */  
    @Override
    public Collection doBetweenSharding(Collection availableTargetNames,  
            ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(availableTargetNames.size());  
        Range range = (Range) shardingValue.getValueRange();  
        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {  
            for (String each : availableTargetNames) {  
                if (each.endsWith(i % 2 + "")) {  
                    result.add(each);  
                }  
            }  
        }  
        return result;  
    }  
  
}  
9、创建分表逻辑
9-1、User分表逻辑UserSingleKeyTableShardingAlgorithm

package com.lyz.sharding.algorithm;  
 
import java.util.Collection;  
import java.util.LinkedHashSet;  
 
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;  
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;  
import com.google.common.collect.Range;  
/** 
 * 因为t_student实际表在每个库中只有3个,所以 %3 
 * @author iuyazhuang
 * 
 */  
public class UserSingleKeyTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm{  
 
    /** 
     * sql 中 = 操作时,table的映射 
     */  
    public String doEqualSharding(Collection tableNames, ShardingValue shardingValue) {  
        for (String each : tableNames) {  
            if (each.endsWith(("0".concat(String.valueOf(shardingValue.getValue() % 3))))) {  
                return each;  
            }  
        }  
        throw new IllegalArgumentException();  
    }  
 
    /** 
     * sql 中 in 操作时,table的映射 
     */  
    public Collection doInSharding(Collection tableNames, ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(tableNames.size());  
        for (Integer value : shardingValue.getValues()) {  
            for (String tableName : tableNames) {  
                if (tableName.endsWith(("0".concat(String.valueOf(value % 3))))) {  
                    result.add(tableName);  
                }  
            }  
        }  
        return result;  
    }  
 
    /** 
     * sql 中 between 操作时,table的映射 
     */  
    public Collection doBetweenSharding(Collection tableNames,  
            ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(tableNames.size());  
        Range range = (Range) shardingValue.getValueRange();  
        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {  
            for (String each : tableNames) {  
                if (each.endsWith(("0".concat(String.valueOf(i % 3))))) {  
                    result.add(each);  
                }  
            }  
        }  
        return result;  
    }  
 
}  
9-2、创建Student分表逻辑StudentSingleKeyTableShardingAlgorithm
package com.lyz.sharding.algorithm;
 import java.util.Collection;  
import java.util.LinkedHashSet;  
  
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;  
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;  
import com.google.common.collect.Range;  
  
/** 
 * 因为t_student实际表在每个库中只有2个,所以 %2 
 * @author iuyazhuang
 * 
 */  
public class StudentSingleKeyTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm{  
  
    /** 
     * sql 中 = 操作时,table的映射 
     */  
    public String doEqualSharding(Collection tableNames, ShardingValue shardingValue) {  
        for (String each : tableNames) {  
            if (each.endsWith("0".concat(String.valueOf(shardingValue.getValue() % 2)))) {  
                return each;  
            }  
        }  
        throw new IllegalArgumentException();  
    }  
  
    /** 
     * sql 中 in 操作时,table的映射 
     */  
    public Collection doInSharding(Collection tableNames, ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(tableNames.size());  
        for (Integer value : shardingValue.getValues()) {  
            for (String tableName : tableNames) {  
                if (tableName.endsWith("0".concat(String.valueOf(value % 2)))) {  
                    result.add(tableName);  
                }  
            }  
        }  
        return result;  
    }  
  
    /** 
     * sql 中 between 操作时,table的映射 
     */  
    public Collection doBetweenSharding(Collection tableNames,  
            ShardingValue shardingValue) {  
        Collection result = new LinkedHashSet(tableNames.size());  
        Range range = (Range) shardingValue.getValueRange();  
        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {  
            for (String each : tableNames) {  
                if (each.endsWith("0".concat(String.valueOf(i % 2)))) {  
                    result.add(each);  
                }  
            }  
        }  
        return result;  
    }  
  
}  
10、创建Mapper.xml
10-1、创建UserMapper.xml

 
 
 
   
     
     
     
     
 
 
    
   
    insert into t_user (user_id,name,age) values (#{userId},#{name},#{age})  
 
 
    
   
    
   
    
   
     id,user_id,name,age  
 
     
 
10-2、创建StudentMapper.xml

 
 
 
   
     
     
     
     
 
 
    
   
    insert into t_student (student_id,name,age) values (#{studentId},#{name},#{age})  
 
 
    
   
    
   
    
   
     id,student_id,name,age  
 
     
 
11、创建jdbc_dev.properties
jdbc_driver0   = com.mysql.jdbc.Driver
jdbc_url0      = jdbc:mysql://localhost:3306/sharding_0?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
jdbc_username0 = root
jdbc_password0 = root
  
jdbc_driver1   = com.mysql.jdbc.Driver
jdbc_url1      = jdbc:mysql://localhost:3306/sharding_1?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
jdbc_username1 = root
jdbc_password1 = root
  
  
validationQuery=SELECT 1
12、创建spring配置文件
12-1、spring-database.xml

 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">  
          
     
         
             
                classpath:config/resource/jdbc_dev.properties  
           
 
       
 
   
 
          
     
         
         
         
 
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
   
 
      
     
         
         
         
 
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
   
 
      
  
 
12-2、spring-sharding.xml
 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">  
          
     
     
     
         
         
   
 
      
     
       
         
         
   
 
      
      
     
     
         
             
                 
                 
           
 
       
 
   
 
      
     
     
         
         
             
                t_user_00  
                t_user_01  
                t_user_02  
           
 
       
 
         
         
         
   
 
      
     
     
         
         
             
       
 
   
 
      
     
     
         
         
             
       
 
   
 
      
      
      
       
     
         
         
             
                t_student_00  
                t_student_01  
           
 
       
 
         
         
         
   
 
      
       
     
         
         
             
       
 
   
 
      
     
     
         
         
             
       
 
   
 
      
      
     
     
         
         
             
                 
                 
           
 
       
 
   
 
      
     
     
         
   
 
  
     
     
         
   
 
  
     
          
 
13、创建log4j.xml
     
   
   
     
     
         
         
         
           
     
   
 
   
    
     
     
         
         
         
         
         
       
     
   
   
   
    
       
       
         
         
         
         
         
         
           
     
   
   
   
    
       
       
         
         
         
         
         
       
     
   
   
   
    
       
       
         
         
         
   
   
    
       
       
           
           
           
          
          
   
   
   
14、创建测试类ShardingJdbcMybatisTest
package com.lyz.sharding.test;  
 
import java.util.Arrays;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import com.lyz.sharding.entity.Student;
import com.lyz.sharding.entity.User;
import com.lyz.sharding.service.StudentService;
import com.lyz.sharding.service.UserService;
 
/**
 * 测试分库分表规则
 * @author liuyazhuang
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations = { "classpath*:config/spring/spring-database.xml", "classpath*:config/spring/spring-sharding.xml" })  
public class ShardingJdbcMybatisTest {  
 
    @Resource  
    public UserService userService;  
      
    @Resource  
    public StudentService studentService;  
 
    @Test  
    public void testUserInsert() {  
        User u = new User();  
        u.setUserId(11);  
        u.setAge(25);  
        u.setName("github");  
        Assert.assertEquals(userService.insert(u), true);  
    }  
      
    @Test  
    public void testStudentInsert() {  
        Student student = new Student();  
        student.setStudentId(21);  
        student.setAge(21);  
        student.setName("hehe");  
        Assert.assertEquals(studentService.insert(student), true);  
    }  
 
    @Test  
    public void testFindAll(){  
        List users = userService.findAll();  
        if(null != users && !users.isEmpty()){  
            for(User u :users){  
                System.out.println(u);  
            }  
        }  
    }  
      
    @Test  
    public void testSQLIN(){  
        List users = userService.findByUserIds(Arrays.asList(1));  
        if(null != users && !users.isEmpty()){  
            for(User u :users){  
                System.out.println(u);  
            }  
        }  
    }  
      
    @Test  
    public void testTransactionTestSucess(){  
        userService.transactionTestSucess();  
    }  
      
    @Test(expected = IllegalAccessException.class)  
    public void testTransactionTestFailure() throws IllegalAccessException{  
        userService.transactionTestFailure();  
    }  
}  
三、测试
我们进行ShardingJdbcMybatisTest类,查看数据表数据,即可看到我们的程序利用sharding-jdbc实现了分库分表操作。

四、温馨提示
大家可以到链接http://download.csdn.net/download/l1028386804/10258290下载完整的sharding-jdbc分库分表实例源代码
 

 

 

你可能感兴趣的:(java)