使用 Hibernate Shards 对数据进行切分
当一个大型应用试图在一个单一的数据库表增加TB的数据时，性能经常会下降，对所有数据编索引对数据的读写都会很耗时，显然，如果我们根据某种策略将单一的表数据存储到不同的数据库表中，将会大大提高性能，切分将是一个令人振奋的可选方法。
切分分为纵向切分和横向切分，纵向切分就是将数据库表为单元进行切分，不同的数据存储到不同的数据库中，例如：有数据库表A，B，其中A存储在数据库A中，B存储在数据库中。
横向切分，将同一个表的数据进行切分，表中的数据分别存储到不同的数据库中，例如：同一个数据库表，亚洲的数据存储在数据库A中，其它洲的存储在数据库B中。
hibernate Shards 就是一个让应用横向切分的分布式数据库解决方案，它可以让一个 Hibernate应用很简单的加入横向切分功能，以下是我在通过参考一些文摘后应用JAVA写的一个测试例子，本例子就以存储 天气预报 信息来进行，我们将要做的是将天气预报信息按洲的方式存储到对应的数据库，来达到性能的提升。
在继续本例程开始之前你需要下载：
Hibernate3.2 应用开发包：http://sourceforge.net/projects/hibernate/files/hibernate3/
Hibernate3.0 Shards 应用开发包：http://sourceforge.net/projects/hibernate/files/hibernate-shards/
Spring2.5 应用开发包：http://www.springsource.org/download
开发包准备好后我们按以下过程来开始Hibernate Shards 旅程：
1、创建数据库与数据库表：
在本示例我将使用SQL SERVER 200 来做测试
create database ASIA --亚洲相关信息数据库
create database AFRICA --非洲相关信息数据库
GO
--在ASIA与AFRICA 数据库中分别创建天气预报数据表
--创建天气序报数据表
IF EXISTS(SELECT 1 FROM SYSOBJECTS WHERE NAME='WEATHER_REPORT')
DROP TABLE WEATHER_REPORT
GO
CREATE TABLE WEATHER_REPORT (
REPORT_ID VARCHAR(50) PRIMARY KEY DEFAULT 0 NOT NULL, --预报ID
CONTINENT varchar(20) not null, --所属的洲
LATITUDE FLOAT, --纬度
LONGITUDE FLOAT, --经度
TEMPERATURE INT, --温度
REPORT_TIME datetime --预报日期
)
2、创建工程
为了更切实意，我使用MYECLIPSE创建一个名为:hibernateShards JAVA 工程并将下载的相关应用包添加引用，开发可根据自身使用的工具选择
2.1、创建hibernate 相关切分配置文件shard0.hibernate.cfg.xml 和 shard1.hibernate.cfg.xml
shard0.hibernate.cfg.xml:
<!-- 切分的 hibernate 配置文件,每个数据库都应有这样一个描述文件 -->
<hibernate-configuration>
<session-factory name="HibernateSessionFactory0">
<property name="dialect">org.hibernate.dialect.SQLServerDialect</property>
<property name="connection.driver_class">com.microsoft.jdbc.sqlserver.SQLServerDriver</property>
<property name="connection.url">jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=ASIA</property>
<property name="connection.username">sa</property>
<property name="connection.password">sa</property>
<!-- 切分 ID,需保持一致 -->
<property name="hibernate.connection.shard_id">0</property>
<!-- 对跨切分关系是否进行检查,在生产环境尽量设为 false,因为检查会非常花时间 -->
<property name="hibernate.shard.enable_cross_shard_relationship_checks">true</property>
</session-factory>
</hibernate-configuration>
shard1.hibernate.cfg.xml:
<hibernate-configuration>
<session-factory name="HibernateSessionFactory0">
<property name="dialect">org.hibernate.dialect.SQLServerDialect</property>
<property name="connection.driver_class">com.microsoft.jdbc.sqlserver.SQLServerDriver</property>
<property name="connection.url">jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=AFRICA</property>
<property name="connection.username">sa</property>
<property name="connection.password">sa</property>
<!-- 切分 ID,需保持一致 -->
<property name="hibernate.connection.shard_id">1</property>
<!-- 对跨切分关系是否进行检查,在生产环境尽量设为 false,因为检查会非常花时间 -->
<property name="hibernate.shard.enable_cross_shard_relationship_checks">true</property>
</session-factory>
</hibernate-configuration>
我们看到以上二个文件内容非常类似，唯一不同的是数据库名和切分ID不同
2.2、建立相关hibernate对象关系映射文件和相关持久对象
weather.hbm.xml
<hibernate-mapping package="com.hibernateshards.po">
<class name="WeatherReport" table="weather_report" dynamic-update="true"
dynamic-insert="true">
<id name="reportId" column="REPORT_ID" unsaved-value="-1">
<!-- 在这里使用 UUID 来生成主键,以防止ID在插入不同的数据库中ID值重复 -->
<generator class="org.hibernate.shards.id.ShardedUUIDGenerator"></generator>
</id>
<property name="continent" column="CONTINENT" type="string"></property>
<property name="latitude" column="LATITUDE" type="float"></property>
<property name="longitude" column="LONGITUDE" type="float"></property>
<property name="tempErature" column="TEMPERATURE" type="int"></property>
<property name="reportTime" column="REPORT_TIME" type="date"></property>
</class>
</hibernate-mapping>
持久对象：WeatherReport.java
/**
* 天气预报相关信息对象
*
* @date 2010-10-23下午06:38:21
*
* @author ChenTao
*/
public class WeatherReport {
private BigInteger reportId;
private String continent;
private Float latitude;
private Float longitude;
private Integer tempErature;
private Date reportTime;
// getter 和 setter 方法略.....
}
2.3、定义切分选策略和创建SessionFactory 对象
WeatherShardSelectionStrategy.java
/**
*
* 切分选择策略,根据自已定义
*
* @date 2010-10-23下午06:58:04
*
* @author ChenTao
*/
public class WeatherShardSelectionStrategy implements ShardSelectionStrategy{
/**
* 选择策略:
* 如果持久化对象是一个 WeatherReport,那么其所在的洲被确定，因此选择了一个切分。在这种情况下，
* 有两个切分：0 和 1，其中切分 0 中包含 亚洲 相关天气预报，切分 1 中包含除亚洲之外所有的洲天气预报。
* 当然在这里可以将每个洲都定义，但这里只做一个测试应用，只描述其操作流程
*
*/
public ShardId selectShardIdForNewObject(Object obj) {
if(obj instanceof WeatherReport){
WeatherReport weatherReport = (WeatherReport) obj;
return this.continentShardId(weatherReport.getContinent());
}
throw new IllegalArgumentException();
}
/**
* 根据洲来获取切分
*
* @param continent
* @return
*/
private ShardId continentShardId(String continent){
if(Constants.CONTINENT_ASIA.equals(continent)){
return new ShardId(0);
} else {
return new ShardId(1);
}
}
}
// 创建SessionFactory
ShardedSessionFactoryBuilder.java
public class ShardedSessionFactoryBuilder {
private List<String> hibernateConfigurations;
private List<String> resourceConfigurations;
public void setHibernateConfigurations(List<String> hibernateConfigurations) {
this.hibernateConfigurations = hibernateConfigurations;
}
public void setResourceConfigurations(List<String> resourceConfigurations) {
this.resourceConfigurations = resourceConfigurations;
}
public SessionFactory createSessionFactory(){
Configuration propotypeConfig = this.getPrototypeConfig(this.hibernateConfigurations.get(0), this.resourceConfigurations);
List<ShardConfiguration> shardConfigs = new ArrayList<ShardConfiguration>();
for(String hibernateConfig:this.hibernateConfigurations){
shardConfigs.add(this.buildShardConfig(hibernateConfig));
}
ShardStrategyFactory shardStrategyFactory = buildShardStrategyFactory();
ShardedConfiguration shardedConfig = new ShardedConfiguration(propotypeConfig,shardConfigs,shardStrategyFactory);
return shardedConfig.buildShardedSessionFactory();
}
/**
* 创建一个 Hibernate 配置
*
* @param hibernateFile
* hibernate 切分配置文件
* @param resourceFiles
* 资源文件
*
* @return
*/
public Configuration getPrototypeConfig(String hibernateFile,List<String> resourceFiles){
Configuration prototypeConfig = this.getConfiguration(hibernateFile);
for(String res:resourceFiles){
prototypeConfig.addResource(res);
}
return prototypeConfig;
}
public Configuration getConfiguration(String hibernateFile){
return new Configuration().configure(hibernateFile);
}
private ShardStrategyFactory buildShardStrategyFactory(){
ShardStrategyFactory shardStrategyFactory = new ShardStrategyFactory(){
public ShardStrategy newShardStrategy(List<ShardId> shardIds){
ShardSelectionStrategy pss = new WeatherShardSelectionStrategy();
ShardResolutionStrategy prs = new AllShardsShardResolutionStrategy(shardIds);
ShardAccessStrategy pas = new SequentialShardAccessStrategy();
return new ShardStrategyImpl(pss,prs,pas);
}
};
return shardStrategyFactory;
}
private ShardConfiguration buildShardConfig(String hibernateConfig){
return new ConfigurationToShardConfigurationAdapter(this.getConfiguration(hibernateConfig));
}
}
2.4、定义数据访问接口和实现对象
接口定义
WeatherReportDao.java
/**
* 天气预报数据操作相关接口定义
*
* @date 2010-10-23下午06:38:50
*
* @author ChenTao
*/
public interface WeatherReportDao {
/**
* 查询所有天气预报相关数据
*
* @return
* @throws HibernateException
*/
List<WeatherReport> findAll() throws HibernateException;
/**
* 根据天气预报ID进行查询
*
* @param id java.lang.Integer
*
* @return
* @throws HibernateException
*/
WeatherReport findById(Integer id) throws HibernateException;
/**
* 查据天气预报所在的洲进行查询
*
* @param continent java.lang.String
*
* @return
* @throws HibernateException
*/
List<WeatherReport> findByContinent(String continent) throws HibernateException;
/**
* 保存天气预报数据
*
* @param weather com.hibernateshards.po.WeatherReport
*
* @throws HibernateException
*/
void save(WeatherReport weather) throws HibernateException;
/**
* 更改天气预报数据
*
* @param weather com.hibernateshards.po.WeatherReport
*
* @throws HibernateException
*/
void update(WeatherReport weather) throws HibernateException;
/**
* 删除天气预报数据
*
* @param weather com.hibernateshards.po.WeatherReport
*
* @throws HibernateException
*/
void delete(WeatherReport weather) throws HibernateException;
}
真实的数据操作对象
WeatherReportDaoImpl.java
/**
* 天气预报数据层交互对象,用于处理数据的查找与CURD操作
*
* @date 2010-10-23下午06:28:25
*
* @author ChenTao
*/
public class WeatherReportDaoImpl implements WeatherReportDao {
private SessionFactory sessionFactory;
public WeatherReportDaoImpl() {
super();
}
@SuppressWarnings("unchecked")
public List<WeatherReport> findAll() throws HibernateException {
return (List<WeatherReport>) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
return session.createQuery("from WeatherReport w")
.list();
}
});
}
@SuppressWarnings("unchecked")
public List<WeatherReport> findByContinent(final String continent)
throws HibernateException {
return (List<WeatherReport>) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
return session
.createQuery(
"from WeatherReport as weather where weather.continent=?")
.setString(0, continent.trim()).list();
}
});
}
public WeatherReport findById(final Integer id) throws HibernateException {
return (WeatherReport) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
return session
.createQuery(
"from WeatherReport as weather where weather.reportId=?")
.setInteger(0, id).uniqueResult();
}
});
}
public void save(final WeatherReport weather) throws HibernateException {
this.getHibernateTemplate().save(weather);
}
public void update(final WeatherReport weather) throws HibernateException {
this.getHibernateTemplate().saveOrUpdate(weather);
}
public void delete(final WeatherReport weather) throws HibernateException {
this.getHibernateTemplate().delete(weather);
}
public void setSessionFactory(final SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
private HibernateTemplate getHibernateTemplate() {
return new HibernateTemplate(sessionFactory);
}
}
2.5、配置Spring
因为前面我们以经下载了 spring 相关开发包，我将要使用spring来加载相关配置和托管相应Bean创建和SessionFactory对象的创建
weatherSpring-config.xml
<beans> <bean id="shardedSessionFactoryBuilder" class="com.hibernateshards.shardsupport.ShardedSessionFactoryBuilder"> <property name="hibernateConfigurations"> <list> <value>shard0.hibernate.cfg.xml</value> <value>shard1.hibernate.cfg.xml</value> </list> </property> <property name="resourceConfigurations"> <list> <value>com/hibernateshards/po/weather.hbm.xml</value> </list> </property> </bean> <!-- 连接域对象 --> <bean id="sessionFactory" factory-bean="shardedSessionFactoryBuilder" factory-method="createSessionFactory"></bean> <bean id="weatherReportDao" class="com.hibernateshards.domain.WeatherReportDaoImpl"> <property name="sessionFactory"> <ref bean="sessionFactory"/> </property> </bean> </beans>
2.6、测试
通过以上的流程下来所有需要实现的代码和配置都已完成，虽然写了这么多，也不知道是否真的可以实现跨数据进行数据库的CRUD操作，为了验证真实性，我写了一个测试对象进
行测试，包含对数据的CRUD 都通过测试，来看下面测试方法：
WeatherReportTest.java
/**
* 对 Shards 进行测试
*
* @date 2010-10-23下午06:37:56
* @author ChenTao
*/
public class WeatherReportTest {
/**
* Spring 的上下文，
*/
private static ApplicationContext ac;
/**
* 数据操作对象
*/
private static WeatherReportDao weatherReportDao;
public static void main(String[] args) {
try {
/* 加载 spring 配置 */
loadConfig();
weatherReportDao = (WeatherReportDao) getAc().getBean("weatherReportDao");
/* 亚洲,以下数据将会增加到 ASIA 数据库中 */
// save(Constants.CONTINENT_ASIA);
/* 非洲,以下数据将会增加到 AFRICA 数据库中 */
// save(Constants.CONTINENT_AFRICA);
/* 对数据进行修改 */
// update();
/* 对数据进行删除 */
// delete();
List<WeatherReport> weatherList = null;
/* 查询所有天气预报数据，这将会扫描所有的数据库 */
weatherList = finaAll();
print(weatherList);
// // 按洲查询,指定某个数据库查询,其体看配置
// weatherList = findByContinent(Constants.CONTINENT_ASIA);
// print(weatherList);
} catch (Exception e) {
e.printStackTrace();
}
}
private static List<WeatherReport> finaAll() throws Exception {
if (null != weatherReportDao) {
return weatherReportDao.findAll();
}
throw new Exception("No Data!");
}
private static List<WeatherReport> findByContinent(String continent)
throws Exception {
if (null != weatherReportDao) {
return weatherReportDao.findByContinent(continent);
}
throw new Exception("No Data!");
}
private static void save(String continent) throws Exception {
if (null != weatherReportDao) {
WeatherReport weather = new WeatherReport();
weather.setContinent(continent);
weather.setLatitude(30.20F);
weather.setLongitude(60.10F);
weather.setTempErature(28);
weather.setReportTime(new java.sql.Date(new java.util.Date()
.getTime()));
weatherReportDao.save(weather);
System.out.println("数据保存成功");
}
}
private static void update() throws Exception {
WeatherReport weather = new WeatherReport();
weather.setReportId(BigInteger.valueOf((long)100));
weather.setContinent(Constants.CONTINENT_ASIA);
weather.setLatitude(100.20F);
weather.setLongitude(100.10F);
weather.setTempErature(34);
weather.setReportTime(new java.sql.Date(new java.util.Date()
.getTime()));
weatherReportDao.update(weather);
System.out.println("数据修改成功");
}
private static void delete() throws Exception {
WeatherReport weather = new WeatherReport();
weather.setReportId(BigInteger.valueOf((long)100));
weather.setContinent(Constants.CONTINENT_ASIA);
weather.setLatitude(50.20F);
weather.setLongitude(60.10F);
weather.setTempErature(28);
weather.setReportTime(new java.sql.Date(new java.util.Date()
.getTime()));
weatherReportDao.delete(weather);
System.out.println("数据删除成功");
}
private static void loadConfig() throws Exception {
loadConfig("weatherSpring-config.xml");
}
private static void loadConfig(String configFile) throws Exception {
ac = (new ClassPathXmlApplicationContext(configFile));
}
public static ApplicationContext getAc() {
return ac;
}
private static void print(List<WeatherReport> weatherList) {
if (null != weatherList && weatherList.size() > 0) {
for (WeatherReport w : weatherList) {
System.out.println("预报ID:" + w.getReportId() + "=洲"
+ w.getContinent());
}
}
}
}
通过以上测试我们发现，当 Continent 为 ASIA 数据插入到了 ASIA 数据库中，当Continent 为 AFRICA 数据插入到了AFRICA数据库中，同时我们在查询的时候可以查询所有的数
据，查询所有的数据在这里不建议使用，我在这里提供了findByContinent按洲查询，这样就只会读取相关洲的数据库，而避免了在读取相应洲的数据时排描所有洲的数据，增加了
应用程序的读写效率，这样对于一个大型应中，数据量大的应用是一个非常适用的一个选择。
但使用切分不足的时一定要确定应用程序的规模和数据增长量，对于一般中小型应用不建议使用横向切分，因为横向切分会带来应用的开发成本和资源成本，当应用需要改变会增加维护成本，并且需要设定应用的存储和检索的特定逻辑
需要有朋友可以下载本例程的实例代码，由于上传文件大小有限制，所以本人只上传了相应的源代码，相应的开发工具包需要读者自身下载并导入。本例程的代码本人都经过测试并成功运行，如有问题可加：63267818 群进行讨论
本例程参考文摘：
Hibernate Shards：http://docs.jboss.org/hibernate/shards/3.0/reference/en/html_single/
Hibernate Shards API Documentation
http://docs.jboss.org/hibernate/stable/shards/api/
http://www.cnblogs.com/RicCC/archive/2010/04/14/hibernate-shards-3-architecture.html