本文目录一览：
- 1、如何用java实现mysql数据库的导入导出
- 2、怎么样实现java与MYSQL的连接？
- 3、怎么用java实现mysql的复制数据库里所有的表跟数据
- 4、如何用java 5分钟实现一个最简单的mysql代理服务器
如何用java实现mysql数据库的导入导出
MySql导出数据库的命令如下：
Sql代码
mysqldump -uusername -ppassword -hhost -Pport exportDatabaseName exportPath
mysqldump -uusername -ppassword -hhost -Pport exportDatabaseName exportPath
利用Java调用命令窗口执行命令来进行MySql导入数据库一般分三步走：
第一步：登录Mysql数据库，在登录数据库的时候也可以指定登录到哪个数据库，如果指定了则可以跳过第二步；
第二步：切换数据库到需要导入的目标数据库
第三步：利用命令开始导入
在进行导出的时候，需要注意命令语句的运行环境，如果已经将mysql安装路径下的bin加入到
系统的path变量中，那么在导出的时候可以直接使用命令语句，否则，就需要在执行命令语句的
时候加上命令所在位置的路径，即mysql安装路径想的bin下的mysqldump命令。
怎么样实现java与MYSQL的连接？
package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import org.apache.struts.util.MessageResources;
public class DBconnection {
private String driveName = null;
private String userName = null;
private String password = null;
private String url = null;
private Connection con =null;
private Statement sta=null ;
private PreparedStatement pre = null;
private ResultSet result = null;
/** 创建一个没有参数的数据库构造器
*
*
*/
public DBconnection() {
construts();
linkDataBase();
}
public DBconnection(Connection con){
this.con=con;
}
/** 实例化对象时调用的方法
*
*MessageResources
*/
private void construts() {
MessageResources message=MessageResources.getMessageResources("resources.application");
driveName = message.getMessage("driveName");
url = message.getMessage("url");
userName = message.getMessage("userName");
password = message.getMessage("password");
}
/** 加载数据库的驱动程ry {
Class.序
*
*
*/
private void linkDataBase() {
try {
Class.forName(driveName);
} catch (ClassNotFoundException e) {
System.out.println("Link DataBase Fail!");
}
}
/** 建立一个Connection对象
*
*
*/
public Connection createConnection() {
try {
con = DriverManager.getConnection(url, userName, password);
return con;
} catch (SQLException e) {
System.out.println("Connection Opened Fail!!");
e.printStackTrace();
}
return null;
}
/** 建立一个Statement对象
*
*
*/
public void createNormalStatement() {
try {
sta = con.createStatement();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("NormalStatement Opened Fail!!");
}
}
/** 设置一个预编译对象
*
* @param sql 初始化预编译的语句
*/
public void createPreparedStatement(String sql) {
try {
pre = con.prepareStatement(sql);
} catch (SQLException e) {
System.out.println("PreparedStatement Opened Fail!!");
}
}
/**建立一个指定sql语句的ResultSet对象
*
* @param sql 一条普通的查询Sql语句,
*/
public void setResultSet(String sql) {
try {
result = sta.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
System.out.println("Nomal resultset get failer!");
}
}
/**执行准备好的 SQL 查询并返回针对查询SQL漏洞
*
*
*/
public void setPreparedStatementResultSet() {
try {
result = pre.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("PreparedStatement resultset get failer!");
}
}
/** 判断当前的Result对象中是否有结果集，有返回真，没有返回假
*
* @return 是否有下一条记录
*/
public boolean haveMoreResult() {
try {
return result.next();
} catch (SQLException e) {
System.out.println("block result next have errors");
return false;
}
}
/**关闭当前对象的Statement对象
*
*
*/
public void closeNormalStatement() {
try {
sta.close();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("NormalStatement close fail!");
}
}
/** 关闭当前的Prepared对象
*
*
*/
public void closePreparedStatement() {
try {
pre.close();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("PreparedStatement close fail!");
}
}
/**关闭当前的ResulrSet对象
*
*
*/
public void closeResultSet() {
try {
result.close();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("Result close fail!");
}
}
/** 关闭Connection对象,检查ResultSet,Statement,PrepardStament是否为空，
* 不为空就关闭，最后关闭Connection
*
*
*/
public void closeConnection() {
try {
if (result != null) {
result.close();
}
if (sta != null) {
sta.close();
}
if (pre != null) {
pre.close();
}
con.close();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("Connection close fail!");
}
}
/** 设置Connection对象事务的支持
*
* @param bool 开启变量
*/
public void setAutoCommit(Boolean bool) {
try {
con.setAutoCommit(bool);
} catch (SQLException e) {
e.printStackTrace();
}
}
/** 通过整数获取ResultSet中的字符串值
*
* @param number 指定ResultSet中的列索引
* @return 获得该值
*/
public String getResultSetValueByNumber(int number) {
try {
return result.getString(number);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/** 通过名字来获得ResultSet指定列的字符串值
*
* @param columnName 指定的ResultSet列的名字
* @return 获得该值
*/
public String getResultSetValueByColumn(String columnName) {
try {
return result.getString(columnName);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/** 通过整数获取ResultSet中的整数值
*
* @param number 指定ResultSet中的列索引
* @return 获得该值
*/
public int getResultSetIntValueByNumber(int number) {
try {
return result.getInt(number);
} catch (SQLException e) {
e.printStackTrace();
}
return -1;
}
/**通过名字来获得ResultSet指定列的整数值
*
* @param columnName 指定的ResultSet列的名字
* @return 获得该值
*/
public int getResultSetIntValueByColumn(String columnName) {
try {
return result.getInt(columnName);
} catch (SQLException e) {
e.printStackTrace();
}
return -1;
}
/** 设置预编译语句的指定的数值列的？String值
*
* @param number 预编译语句中？的索引
* @param value 相应的要传入的值
* @return 是否成功设置
*/
public boolean setPreparedStatementStringValue(int number, String value) {
try {
pre.setString(number, value);
return true;
} catch (SQLException e) {
e.printStackTrace();
System.out.println("setPreparedStatementStringValue failer "
+ number);
}
return false;
}
/**设置预编译语句的指定的数值列的？int值
*
* @param number 预编译语句中？的索引
* @param value 相应的要传入的值
*/
public void setPreparedStatementIntValue(int number, int value) {
try {
pre.setInt(number, value);
} catch (SQLException e) {
e.printStackTrace();
System.out.println("setPreparedStatementIntValue failer " + number);
}
}
/** 提交preparedStatement(预编译)针对多表事物语句
*
* @return 是否成功提交该语句
*/
public boolean preExecuteUpdate() {
try {
pre.executeUpdate();
return true;
} catch (SQLException e) {
e.printStackTrace();
}
return false;
}
/**提交事物（多条SQL一起提交）
*
*
*/
public void conCommit() {
try {
con.commit();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("Transfer has failer!");
}finally{
closeConnection();
}
}
/** 数据库事物不成功的时候回滚
*
*
*/
public void conRollback() {
try {
con.rollback();
System.out.println("database rollback");
} catch (SQLException e) {
e.printStackTrace();
}finally{
closeConnection();
}
}
/** 运行一条普通的Insert,Update,Delete语句
*
* @param sql 普通的INSERT，UPDATE，DELETE语句
* @return 是否成功操作
*/
public boolean insertUpdateDelete(String sql) {
try {
sta.executeUpdate(sql);
return true;
} catch (SQLException e) {
e.printStackTrace();
}
return false;
}
// 测试程序
// public static void main(String[] args) {
// DBconnection db = new DBconnection();
// db.createConnection();
// db.createNormalStatement();
// String sql = "select * from book_infor;";
// db.setResultSet(sql);
// if (db.haveMoreResult()) {
// System.out.println(db.getResultSetIntValueByNumber(1));
// System.out.println(db.getResultSetValueByNumber(2));
// System.out.println(db.getResultSetValueByNumber(3));
// System.out.println(db.getResultSetValueByNumber(4));
// System.out.println(db.getResultSetValueByNumber(5));
// System.out.println(db.getResultSetValueByNumber(6));
// }
// }
}这个是jdbc，海有个连接池。
MySQl安装个安装版的，有图形界面的。
怎么用java实现mysql的复制数据库里所有的表跟数据
楼主要考虑的不仅仅是标题的需求。
1、复制数据库里所有的表和数据的目的是什么。
a、假设楼主是要做数据库备份的话，且通过程序来做的话，可以使用程序来执行dos命令
如java：Runtime.getRuntime().exec("e:\\MySQL\\bin\\mysqldump -h localhost -uroot -p123 db_name")
b、假设楼主是要做库与库之间的同步的话，可以使用第三方客户端进行，比如navicat，sqlyong等
c、假设楼主是要做库与库之间的同步且用程序进行的话，可以使用mysql中提供操作数据库的api来做相对应的读取工作和对比工作，然后写入工作
如何用java 5分钟实现一个最简单的mysql代理服务器
如何用java 5分钟实现一个最简单的mysql代理服务器
首先，准备开发工具套件，我们并不会引入过多工具包，仅仅需要：
java8
vert.x 3
如果你是用maven做为项目管理工具，请将vert.x 3引入：
1
2
3
4
5
dependency
groupIdio.vertx/groupId
artifactIdvertx-core/artifactId
version3.3.2/version
/dependency
代码实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package
com.maxleap.mysqlproxy;
import
io.vertx.core.AbstractVerticle;
import
io.vertx.core.Vertx;
import
io.vertx.core.logging.Logger;
import
io.vertx.core.logging.LoggerFactory;
import
io.vertx.core.net.NetClient;
import
io.vertx.core.net.NetServer;
import
io.vertx.core.net.NetSocket;
/**
*
@author sneaky
*
@since 1.0.0
*/
public
class
MysqlProxyServer
{
private
static
final
Logger
logger
=
LoggerFactory.getLogger(MysqlProxyServer.class);
public
static
void
main(String[]
args)
{
Vertx.vertx().deployVerticle(new
MysqlProxyServerVerticle());
}
public
static
class
MysqlProxyServerVerticle
extends
AbstractVerticle
{
private
final
int
port
=
3306;
private
final
String
mysqlHost
=
"10.10.0.6";
@Override
public
void
start()
throws
Exception
{
NetServer
netServer
=
vertx.createNetServer();//创建代理服务器
NetClient
netClient
=
vertx.createNetClient();//创建连接mysql客户端
netServer.connectHandler(socket
-
netClient.connect(port,
mysqlHost,
result
-
{
//响应来自客户端的连接请求，成功之后，在建立一个与目标mysql服务器的连接
if
(result.succeeded())
{
//与目标mysql服务器成功连接连接之后，创造一个MysqlProxyConnection对象,并执行代理方法
new
MysqlProxyConnection(socket,
result.result()).proxy();
