动态新建数据库并连接

最新推荐文章于 2023-06-06 16:31:24 发布
最新推荐文章于 2023-06-06 16:31:24 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： java java web 文章标签： 动态建数据库 hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuezhuo_752/article/details/53396500
版权

动态新建数据库并连接，调用hibernate建表

CreateDataSource类：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Element;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

import com.ioif.wha.cssp.util.ConfigHibernateHelper;
import com.ioif.wha.cssp.util.Constant;
import com.ioif.wha.hibernate.HibernateUtil;

public class CreateDataSource {

	/*** @param args */
	public static void main(String[] args) {
		// TODO Auto-generated method stub 
		String database = "test2";
		new CreateDataSource().getConn(database);
	}

	String mysqlDriver = "com.mysql.jdbc.Driver";
	String url = "jdbc:mysql://192.168.1.201:3306/";
	String newUrl = "jdbc:mysql://192.168.1.201:3306/";
	String username = "sa";
	String password = "asdf123";
	Connection conn = null;
	Connection newConn = null;

	Connection getConn(String database) {
		// TODO Auto-generated method stub
		try {
			Class.forName(mysqlDriver);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block 
			e.printStackTrace();
		}

		try {
			String databaseSql = "create database " + database;
			conn = DriverManager.getConnection(url, username, password);
			System.out.println("数据库连接成功！");
			Statement smt = conn.createStatement();
			smt.executeUpdate(databaseSql);
			
			//
			ConfigHibernateHelper chh = new ConfigHibernateHelper();
			java.util.List<Element> list = chh.read(Constant.CONFIG_FILE_LOCATION, Constant.PROPERTY_XPATH, Constant.MAPPING_XPATH);
			System.out.println("listSize---" + list.size());
			for (int i = 0; i < list.size(); i++) {
				 System.out.println("-----"+list.get(i)+"---------");
			}
			printValue(list);
			System.out.println("连接新的数据库");
			// 模仿前台传送数据
			Map<String, String> paraMap = new HashMap<String, String>();
			paraMap.put(Constant.CONNECTION_URL,
					"jdbc:mysql://192.168.1.201:3306/"+database);
			// 修改缓存配置
			HibernateUtil.getConfiguration(paraMap);
		

			// 改变重新XML
			changeDatabase(paraMap);
		} catch (SQLException e1) {
			// TODO Auto-generated catch block   
			e1.printStackTrace();
		}

		return conn;
	}
	

	private static void changeDatabase(Map<String, String> paraMap) {
		// TODO Auto-generated method stub
		ConfigHibernateHelper helper = new ConfigHibernateHelper();
		// 读取配置文件
		List<Element> nodeList = helper.read(Constant.CONFIG_FILE_LOCATION,
				Constant.PROPERTY_XPATH, Constant.MAPPING_XPATH);
		System.out.println();
		System.out.println();
		System.out.println();
		// 修改前
		printValue(nodeList);
		System.out.println();
		System.out.println();
		System.out.println();
		nodeList = helper.replaceNewValue(paraMap, nodeList);
		helper.write(Constant.CONFIG_FILE_LOCATION, nodeList);
		// 修改后
		printValue(nodeList);
		System.out.println();
		System.out.println();
		System.out.println();

	}

	public static void printValue(List<Element> nodeList) {
		for (Element property : nodeList) {
			String name = property.attributeValue("name");
			String text = property.getText();
			if (Constant.CONNECTION_URL.equals(name)) {
				System.out.println("$" + name + " : " + text + "$");
			}
		}
	}

}

ConfigHibernateHelper类： 

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.xpath.DefaultXPath;


/**
 * 
 * 
 * 描述：<p>    读取、重写Hibernate配置文件的工具类。</p>
 * 创建日期：2012-6-27 上午9:59:49<br>
 * @author：tianyj<br> 
 * @update：$Date$<br>
 * @version：$Revision$<br>
 * @since 版本号，用来指定该类是从整个项目的哪个版本开始加入到项目中的
 */
public class ConfigHibernateHelper {
	
	private SAXReader reader = null;
	private File file = null;
	private String url = null;
	private Document document = null;
	private List<Element> nodeList = null;
	
	private XMLWriter writer = null;
	
	
	/**
	 * 读取XML文件，返回根据过滤条件进行过滤的节点列表
	 * @param fileName 文件名称
	 * @param xpath 过滤条件
	 * @return 节点元素列表
	 */
	public List<Element> read(String fileName, String pro_xpath, String map_xpath){
		reader = new SAXReader(); 
        try {
        	url = this.getFilePath(fileName);
        	file = new File(url);
            reader.setEntityResolver(new NoOpEntityResolver());
            document = reader.read(file);
            // 获得hibernate-configuration:session-factory下的property属性节点列表
            DefaultXPath propertyPath = new DefaultXPath(pro_xpath);
            nodeList = getNodeList(document, propertyPath);
            // 获得hibernate-configuration:session-factory下的mapping属性节点列表
            DefaultXPath mappingPath = new DefaultXPath(map_xpath);  
            List<Element> mappings = getNodeList(document, mappingPath);
            
            nodeList.addAll(mappings);
            
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return nodeList;
	}
	
	/**
	 * 根据条件返回节点列表
	 * @param document 文档变量
	 * @param propertyPath 过滤条件对象
	 * @return
	 */
	@SuppressWarnings("unchecked")
    private List<Element> getNodeList(Document document, DefaultXPath propertyPath) {
	    return propertyPath.selectNodes(document);
    } 
	
	/**
	 * 返回配置文件的路径
	 * @param fileName
	 * @return
	 */
	private String getFilePath(String fileName){
		return getClass().getClassLoader().getResource(fileName).getPath();
	}
	
	/**
	 * 替换从前台传递的配置新的数据库连接属性
	 * @param paraMap 修改的数据key-value
	 * @param nodeList 节点列表
	 */
	public List<Element> replaceNewValue(Map<String,String> paraMap, List<Element> nodeList){
		// 循环需要修改的节点信息，从前台进行传递过来
		for(Map.Entry<String, String> entry : paraMap.entrySet()){
			for (Element property : nodeList) {  
                String name = property.attributeValue("name");
                // 过滤掉Mapping配置文件节点
                String resource = property.attributeValue("resource");
                if(null != resource && "resource".equals(resource)){
                	break;
                }
                // 设置修改后的属性值
                if(entry.getKey().equals(name)
                		|| entry.getKey().equals(name) || entry.getKey().equals(name)){
                	property.setText(entry.getValue());
                }
            }  
		}
		return nodeList;
	}
	
	/**
	 * 把配置信息从新写入
	 * @param nodeList
	 * @param fileName
	 * @return
	 */
	public boolean write(String fileName, List<Element> nodeList){
		url = this.getFilePath(fileName);
		// document
		Document document = DocumentHelper.createDocument();
		// 设置DocType
		document.addDocType("hibernate-configuration" , 
				"-//Hibernate/Hibernate Configuration DTD 3.0//EN" , 
				"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd");
		// hibernate-configuration  
        Element configuration = document.addElement("hibernate-configuration");  
        // session-factory  
        Element sessionfactory = configuration.addElement("session-factory");  
        sessionfactory.addComment("Database connection settings");
        // 添加属性
        for(Element property : nodeList){
        	String name = property.attributeValue("name");
        	String resource = property.attributeValue("resource");
        	String text = property.getText();
        	// property节点操作方式
        	if(null != name && null!=text && !"".equals(name) && !"".equals(text)){
        		Element proElement = sessionfactory.addElement("property");  
        		proElement.addAttribute("name", property.attributeValue("name").trim());  
        		proElement.setText(property.getText().trim());
        	}else if(null != resource && !"".equals(resource)){
        		// mapping节点操作方式
        		Element mapping = sessionfactory.addElement("mapping");
        		mapping.addAttribute("resource", property.attributeValue("resource").trim());
        	}
        	
        }
        
        //设置输出格式  
        OutputFormat format = new OutputFormat();  
        format.setEncoding("utf-8");  
        format.setIndent(true);  
        format.setLineSeparator("\n");  
        format.setNewlines(true);
        
        try {  
            writer = new XMLWriter(format);  
            writer.setOutputStream(new FileOutputStream(url));  
            writer.write(document);  
            writer.flush();  
        } catch (UnsupportedEncodingException e) {  
            e.printStackTrace();  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if(writer != null) {  
                try {  
                    writer.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        } 
		return true;
	}
}

Constant类： 
public class Constant {
	// Hibernate�����ļ����
	public static final String CONFIG_FILE_LOCATION = "hibernate.cfg.xml";
	// �����ļ���URL�������
	public static final String CONNECTION_URL = "hibernate.connection.url";
	// �����ļ�����ݿ��û���
	public static final String CONNECTION_USERNAME = "hibernate.connection.username";
	// �����ļ�����ݿ�����
	public static final String CONNECTION_PASSWORD = "hibernate.connection.password";
	public static final String PROPERTY_XPATH = "/hibernate-configuration/session-factory/property";
	public static final String MAPPING_XPATH = "/hibernate-configuration/session-factory/mapping";
	public static final String ALL_XPATH = "/hibernate-configuration/session-factory";
}

NoOpEntityResolver类： 
import java.io.IOException;
import java.io.StringBufferInputStream;

import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

public class NoOpEntityResolver implements EntityResolver{

	@SuppressWarnings("deprecation")
    public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
	    // TODO Auto-generated method stub
	    return new InputSource(new StringBufferInputStream(""));
    }

}

HibernateUtil类： 
import java.util.Map;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

import com.ioif.wha.cssp.util.Constant;

public class HibernateUtil {
	private static SessionFactory sessionFactory;
	private static Configuration cfg;
	
	private static final Configuration getConfiguration(){
		cfg = new Configuration().configure();
		return cfg;
	}
	
	//使用ThreadLocal管理Session
	private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
	static {
		try {
			//根据hibernate.cfg.xml建立SessionFactory
			sessionFactory = getConfiguration().buildSessionFactory();
		} catch (Throwable ex) {
			ex.printStackTrace();
			System.err.println("建立SessionFactory错误" + ex);
			throw new ExceptionInInitializerError(ex);
		}
	}	
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}	
    public static Session getSession() throws HibernateException {
		Session session = (Session) threadLocal.get();
		if (session == null || !session.isOpen()) {
			session = (sessionFactory != null) ? sessionFactory.openSession(): null;
			threadLocal.set(session);
		}
		return session;
	}    
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);

        if (session != null) {
            session.close();
        }
    }
    
	
	/**
	 * 根据前台传递的数据库配置信息进行立即修改
	 * @param paraMap
	 * @throws EXP_Base
	 */
	public static void getConfiguration(Map<String, String> paraMap){
		try {
			// 在Hibernate的缓存中移除数据库URL、用户名、密码配置信息
			cfg.getProperties().remove(Constant.CONNECTION_URL);
			// 在Hibernate的缓存中添加新的数据库URL、用户名、密码配置信息
			cfg.getProperties().setProperty(Constant.CONNECTION_URL,
					paraMap.get(Constant.CONNECTION_URL));
			/*
			 * 销毁SessionFactory并释放所有资源（缓存，连接池等）。
			 */
			if (sessionFactory != null) {
				sessionFactory.close();
			}
			sessionFactory = cfg.buildSessionFactory();
			SchemaExport export = new SchemaExport(cfg);
			export.create(true, true);
			System.out.println("建表成功！");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}



yuezhuo_752
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis多数据源配置及动态切换——搭建多个数据源并动态切换
禅与计算机程序设计艺术
07-28 2417
随着互联网的发展、移动互联网的兴起和需求的增加，网站应用的规模也越来越庞大。由于业务不同，每个站点会存在不同的数据库，所以在同一个系统中，需要配置多个数据库连接。而 MyBatis 是目前主流的开源持久层框架之一，它的多数据源支持就显得尤为重要。本文将详细介绍 MyBatis 的多数据源配置及动态切换，并结合实际案例实现三个数据库的动态切换。MyBatis 是一款优秀的持久层框架，它可以很方便地通过简单的 XML 或注解的方式来完成对数据库的操作。
动态创建数据库，并初始化数据库
10-12
动态创建数据库并初始化数据库，加上相应的jar包，就可以使用了。
SpringBoot基于MYSQL动态生成数据库
最新发布
qq_40708522的博客
06-06 1240
【代码】SpringBoot基于MYSQL动态生成数据库。
MyBatis系列-动态连接数据库
马各马它
05-11 6237
前言 MyBatis是目前java项目连接数据库的最流行的orm框架了。常用的使用方法是配置datasource，编写dao和mapper，最后通过依赖注入调用dao的方法来操作数据。本篇使用MyBatis来动态生成MyBatis的对象，动态配置数据库连接操作数据库。 动态数据库连接 使用MyBaits常规方式是在xml或者properties来配置MyBatis，但是这样会把配置参数写死。如果想...
利用mybatis动态连接mysql
weixin_44699742的博客
02-12 1031
不知到大家在开发中有没有遇到过需要动态连接数据库的问题，比如填写个数据库的账号密码和连接地址测试是否可以连接通、动态配置数据库取表格数据等等；我最近就遇到了这样一个问题需要动态配置连接数据库，并且能够在连接数据库时可以动态查询不同表格的数据。面对这个问题一般解决方案可以是直接利用jdbc连接并测试，但是面对容器化，orm框架的不断涌现，这种原生方案无疑是重复性造轮子，并且还未必有现有的框架好用，所以本文将介绍利用解决该问题。
oracle新建数据库和连接配置步骤
10-16
oracle新建数据库和连接配置步骤；
Oracle-新建Oracle数据库并连接（图文，详细）.docx
10-26
Oracle-新建Oracle数据库并连接（图文，详细）.docx
C++连接并使用MySQL数据库
12-17
本文实例为大家分享了C++连接并使用MySQL数据库的具体代码，供大家参考，具体内容如下 1. C++连接MySQL数据库 首先在VS里新建C++工程项目，右键工程项目名，选择属性。 选择平台选择 选择配置管理器 选择新建 ...
数据库连接新建文本文档.txt
06-15
数据库连接
MyBatis动态设置要连接的数据库地址，用户名，密码
殇神马的博客
09-04 3184
MyBatis动态设置数据库连接的url，用户名，密码
动态创建数据库
qq_32851113的博客
12-04 583
http://cgs1999.iteye.com/blog/2327637 https://www.cnblogs.com/kings-9/p/7629232.html https://www.cnblogs.com/super-age/p/7289907.html 创建多数据源并动态切换 https://my.oschina.net/simpleton/blog/868608 http...
动态创建数据库！
Welcome to itblog
06-17 1106
create proc pr_createdb@DBNAME sysname,@collation_name sysname,@dNAME sysname,@dFILENAME sysname,@dSIZE int,@dMAXSIZE int,@dFILEGROWTH,@lNAME sysname,@lFILENAME sysname,@lSIZE int,@lMAXSIZE int,@lFILE
MySql存储过程动态创建表并插入数据
热门推荐
学习编程，热爱编程
07-31 1万+
MySql存储过程动态创建表并插入数据          最近做的一个项目，数据库用的是MySql,对于MySql不是很熟练，只是会简单的应用，毕竟简单的sql语句还是相通的，但是随着项目的深入复杂的sql语句开始慢慢多起来，其中一个小难点就是要根据当天的日期动态创建表，并且向其中插入数据。          具体逻辑可以理解为，先去数据库查询有没有当天的记录表，如果没有则创建表，然后执行当天
Mysql之存储过程，动态创建表和数据库-,动态删除-yellowcong
01-18 1万+
今天在弄mycat 的时候，有一个需求，就是创建12个数据库，然后数据库里面都创建一个表，我当时想象，这个玩意也不难，于是寻思通过存储过程来动态创建表，只需要传递进来数据的前缀名称和表名称，即可创建12个表，每个库里面都有一个固定格式的表。存储过程中，不能有tab制表符，不然就报错 存储过程存储过程的动态建表和sql，需要依赖于PREPARE 和EXECUTE 函数,通过动态生成表的方式，大大的加速
Mybatis动态创建数据库表
qq_38785977的博客
09-03 3320
Mybatis动态创建数据库表 描述 ​ 最近实验室的项目中有的需求涉及到需要动态创建数据库表，因此我做了一个小实验，可以通过mybatis中的动态SQL去实现动态创建或删除数据库。在正文之前先介绍一下mybatis的映射配置文件中动态传递参数的两种方式： #{} 占位符 对应的变量会自动加上引号 ${} 拼接符 对应的变量不会自动加上引号 因此在我们动态创建数据库表进行传参的时候一定要注意，我们传递的表名或者列名一定要使用${}进行传参。 基本的创建删除表 <update id="create
C#中动态创建数据库和数据表，很经典【转】
weixin_30279671的博客
02-14 326
用ADOX创建access数据库方法很简单，只需要new一个Catalog对象，然后调用它的Create方法就可以了，如下： ADOX.Catalog catalog = new Catalog(); catalog.Create("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=d:\test.mdb;Jet OLEDB:Engine Typ...
C#解决 动态创建库、动态创建表
赵崇
11-29 1万+
最近在做高校平台，这个系统可以被多个学校使用。既然如此，每个学校所要保存的数据当然不可能存放在一个库中。一个学校一个库，那么有几个学校用呢？未知。得了，库的数量得视情况而定。 动态创建库可以解决这种问题。 而在子系统（考试系统）里面，在题型管理模块，由于题型的数量众多，而且数据库表内容位置。所以采用动态创建数据表来解决此问题。
是新建数据库 不是新建连接
05-30
2. 在“导航器”面板中，右键单击连接，然后选择“新建SQL编辑器”。 3. 在SQL编辑器中输入以下命令来创建数据库： CREATE DATABASE database_name USER SYS IDENTIFIED BY password USER SYSTEM IDENTIFIED ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值