javamysql工具

1. 如何用java实现MySQL数据库的备份和恢复

MySQL的一些前台工具是有备份恢复功能的，可是如何在我们的应用程序中实现这一功能呢？本文提供了示例代码来说明如何使用Java代码实现MySQL数据库的备份恢复。

本次实现是使用了MySQL数据库本身提供的备份命令mysqlmp和恢复命令mysql，在java代码中通过从命令行调用这两条命令来实现备份和恢复。备份和恢复所使用的文件都是sql文件。

本代码是参照网上某网友提供的源码完成的。

[java] view plain
package xxx.utils;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
/**
* MySQL数据库的备份与恢复 缺陷：可能会被杀毒软件拦截
*
* @author xxx
* @version xxx
*/
public class DatabaseBackup {
/** MySQL安装目录的Bin目录的绝对路径 */
private String mysqlBinPath;
/** 访问MySQL数据库的用户名 */
private String username;
/** 访问MySQL数据库的密码 */
private String password;
public String getMysqlBinPath() {
return mysqlBinPath;
}
public void setMysqlBinPath(String mysqlBinPath) {
this.mysqlBinPath = mysqlBinPath;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public DatabaseBackup(String mysqlBinPath, String username, String password) {
if (!mysqlBinPath.endsWith(File.separator)) {
mysqlBinPath = mysqlBinPath + File.separator;
}
this.mysqlBinPath = mysqlBinPath;
this.username = username;
this.password = password;
}
/**
* 备份数据库
*
* @param output
* 输出流
* @param dbname
* 要备份的数据库名
*/
public void backup(OutputStream output, String dbname) {
String command = "cmd /c " + mysqlBinPath + "mysqlmp -u" + username
+ " -p" + password + " --set-charset=utf8 " + dbname;
PrintWriter p = null;
BufferedReader reader = null;
try {
p = new PrintWriter(new OutputStreamWriter(output, "utf8"));
Process process = Runtime.getRuntime().exec(command);
InputStreamReader inputStreamReader = new InputStreamReader(process
.getInputStream(), "utf8");
reader = new BufferedReader(inputStreamReader);
String line = null;
while ((line = reader.readLine()) != null) {
p.println(line);
}
p.flush();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (reader != null) {
reader.close();
}
if (p != null) {
p.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 备份数据库，如果指定路径的文件不存在会自动生成
*
* @param dest
* 备份文件的路径
* @param dbname
* 要备份的数据库
*/
public void backup(String dest, String dbname) {
try {
OutputStream out = new FileOutputStream(dest);
backup(out, dbname);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
/**
* 恢复数据库
*
* @param input
* 输入流
* @param dbname
* 数据库名
*/
public void restore(InputStream input, String dbname) {
String command = "cmd /c " + mysqlBinPath + "mysql -u" + username
+ " -p" + password + " " + dbname;
try {
Process process = Runtime.getRuntime().exec(command);
OutputStream out = process.getOutputStream();
String line = null;
String outStr = null;
StringBuffer sb = new StringBuffer("");
BufferedReader br = new BufferedReader(new InputStreamReader(input,
"utf8"));
while ((line = br.readLine()) != null) {
sb.append(line + "/r/n");
}
outStr = sb.toString();
OutputStreamWriter writer = new OutputStreamWriter(out, "utf8");
writer.write(outStr);
writer.flush();
out.close();
br.close();
writer.close();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 恢复数据库
*
* @param dest
* 备份文件的路径
* @param dbname
* 数据库名
*/
public void restore(String dest, String dbname) {
try {
InputStream input = new FileInputStream(dest);
restore(input, dbname);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Configuration config = HibernateSessionFactory.getConfiguration();
String binPath = config.getProperty("mysql.binpath");
String userName = config.getProperty("connection.username");
String pwd = config.getProperty("connection.password");
DatabaseBackup bak = new DatabaseBackup(binPath, userName, pwd);
bak.backup("c:/ttt.sql", "ttt");
bak.restore("c:/ttt.sql", "ttt");
}
}

最后的main方法只是一个简单的使用方法的示例代码。
本人所做的项目是使用了hibernate的，而这里需要提供MySQL的bin路径和用户名、密码，而hibernate.cfg.xml中本身就是需要配置数据库的用户名和密码，所以我把MySQL的bin路径也直接配置到了这个文件里面，也不需要创建专门的配置文件，不需要写读取配置文件的接口了。
如果不明白，可以去看hibernate.cfg.xml的说明，里面是可以配置其他的property的

2. mySQL在java中的应用

Java连接Mysql详解
Part I: 驱动/数据源类名, URL语法, Connector/J的属性配置.假设你应经安装好了mysql, 和mysql-connector-java-X.X.X-bin.jar
Mysql Connector/J通过com.mysql.jdbc.Driver来实现java.sql.Driver, 同时类名org.gjt.mm.mysql.Driver依旧可用, 以保持向前兼容MM.Mysql.
MySQL的JDBC URL格式如下:
如果没有明确指定host(主机名), 默认为127.0.0.1, 端口号默认是3306
如果不指定数据库名, 不会有默认的数据库, 这样的话, 你可以调用Connection的setCatalog()方法, 或者在SQL中明确指定所用的数据库. 这种情况只在为多个数据库建立工具时有用. 例如建立GUI数据库管理器.
JDBC应该永远不使用USE database来指定数据库, 应该用Connection.setCatalog()方法.
MySQL Connector/J支持fail-over模式, 使用fail-over模式, 必须将connection的autoCommit设置为true.
如果URL的autoReconnect设置为false: Failover会发生在连接初始化时, failback出现在驱动器使第一个主机在此可用时.
如果URL的autoReconnect属性时true, Failover发生在驱动决定connection失败时(在每次查询之前), falls back到第一个主机, 当它决定这个主机在此可用时.
在以上提到的两种情况中, 无论何时你连接到一个"failed-over"服务器, 这个连接将会是制度的, 因此, 修改数据的查询, 将会引发异常.
Configuration properties定义Connctor/J将怎样连接到MySQL服务器. 除了特别声明, 这些属性可以设置在DataSource或Connection object中.
Configuration properties可以按照下面的方式进行设置:
①使用MysqlDataSource或MysqlConnectionPoolDataSource的set*()方法.
②以java.util.Properties的key/value对的形式传递给DriverManager.getConnection() 或Driver.connect()
③作为JDBC URL的参数传给java.sql.DriverManger.getConnection()
java.sql.Driver.connect()或MySQL实现的javax.sql.DataSource setURL() 方法.
注意: 如果你用来确定JDBC URL的机制是XML-based, 你需要使用XML字符 &来分隔参数.

3. Java中的数据库开源管理工具都有哪些

开源数据库MySQLMySQL是一个开放源码的小型关联式数据库管理系统，开发者为瑞典MySQL AB公司。目前MySQL被广泛地应用在Internet上的中小型网站中。由于其体积小、速度快、总体拥有成本低，尤其是开放源...

开源数据库MySQL

MySQL是一个开放源码的小型关联式数据库管理系统，开发者为瑞典MySQL AB公司。目前MySQL被广泛地应用在Internet上的中小型网站中。由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，许多中小型网站为了降低网站总体拥有成本而选择了MySQL作为网站数据库。

4. 怎样用java连接mysql

package com.hhaip.util;

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class DBUtil{
private DBUtil(){}

static{
try{
Class. forName("com.mysql.jdbc.Driver" );
//注册驱动，而且只需要注册一次，可以放到static中，要拿到字节码文件，
//一定要先加载这个类，而且java中每个类只会被加载一次
}catch(ClassNotFoundException e){
System.out.println( "驱动加载失败" );
e.printStackTrace(); //打印堆栈里的错误解释给程序员看
}
}

public static void main(String[] args){}

public static Connection getConn(){
Connection conn = null;//成员变量一定要初始化
try{
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root" ); //jdbc:mysql:///test"
} catch(SQLException e){
e.printStackTrace();
}
return conn;
}

public static Statement getStmt(Connection conn){
Statement stmt = null;
try{
stmt = conn.createStatement();
} catch(SQLException e){
e.printStackTrace();
}
return stmt;
}

public static PreparedStatement getPstmt(Connection conn,String sql){
PreparedStatement pstmt = null;
try{
pstmt = conn.prepareStatement(sql);
} catch(SQLException e){
e.printStackTrace();
}
return pstmt;
}

public static ResultSet getRs(Statement stmt,String sql){
ResultSet rs = null;
try{
rs = stmt.executeQuery(sql);
} catch(SQLException e){
e.printStackTrace();
}
return rs;
}

public static ResultSet getRs(PreparedStatement pstmt){
ResultSet rs = null;
try{
rs = pstmt.executeQuery();
//excuteQuery有返回结果给rs，为什么这里没sql语句，因为pstmt里面已经执行了一句sql
//stmt中没有sql语句，所以它还要传一个sql语句给rs。
} catch(SQLException e){
e.printStackTrace();
}
return rs;
}

public static void close(ResultSet rs){
if(rs!=null ){
try{
rs.close();
rs= null; //让java的垃圾回收机制把没用的内存回收，可以将对象的引用置为空
} catch(SQLException e){
e.printStackTrace();
}
}
}

public static void close(Statement stmt){
if(stmt!=null){
try{
stmt.close();
stmt= null; //让java的垃圾回收机制把没用的内存回收，可以将对象的引用置为空
} catch(SQLException e){
e.printStackTrace();
}
}
}

public static void close(Connection conn){
if(conn!=null){
try{
conn.close();
conn= null; //让java的垃圾回收机制把没用的内存回收，可以将对象的引用置为空
} catch(SQLException e){
e.printStackTrace();
}
}
}

}

1、上面的代码放在一个类里，类名DBUtil.这个类是连接MySQL的工具类，你要先下好MySQL的数据库驱动jar包，还有安装好MySQL。已经上传到附近了。

2、"jdbc:mysql://localhost:3306/test", "root", "root" 这里test是你MySQL里的数据库名称，这里连接了test数据库，你也可以自己新建自己的数据库。两个root分别是数据库的登陆名和密码，安装MySQL的时候设置的，只要在你的DAO里调用我这个工具类就可以了。

5. 如何在Java程序中访问mysql数据库中的数据并进行简单的操作

一、使用工具：java语言、Myeclipse。
二、操作步骤：
1、第一步：加载MySQL的JDBC的驱动

2、第二步：创建与MySQL数据库的连接类的实例

3、第三步：获取连接类实例con，用con创建Statement对象类实例 sql_statement

4、第四步：执行查询，用ResultSet类的对象，返回查询的结果

5、得出数据

三、注意事项：有几处是需要根据自身情况修改的
1、如下图中的url和账号，密码需要与你自己的相一致。

2、这些需要访问的数据必须要与数据库中的类型相互匹配，才能打印出正确的结果。

6. java开发项目最好用那些工具软件mysql+tomcat还是access+sql sever

框架：ssh(struts2 spring hibernate) freemarker ajax
服务器： apache tomcat
工具：eclipse mysql (可以使用Navicat for MySQL来操作mysql简单方便) PowerDesigner(数据库设计)
还有可以装个火狐浏览器安装个firebug插件，页面调试用很方便。
这些都是常用的供你参考。

7. java在eclipse工具里面要如何连接mysql的数据库进行操作啊

应该还有个jar包，你导入没有？看图

8. 基于Java的应用MySQL读写分离用什么工具或类库来实现

利用PerformanceCounter来实现
该类位于System.Diagnostics中
构造函数public PerformanceCounter(string categoryName, string counterName, string instanceName);
参数说明：1、categoryName，计数器类别名
PerformanceCounterCategory[] p = PerformanceCounterCategory.GetCategories();此方法可以获取所有categoryName，例如CPU就是Processor Information
2、 string counterName 实例名和计数器名instanceName
PerformanceCounterCategory pcc = new PerformanceCounterCategory(CategoryName);
string[] s = pcc.GetInstanceNames();此方法可以获取类别名为CategoryName的所有实例名；
再根据实例名去取得该实例下计数器的名称
PerformanceCounter[] pc =pcc.GetCounters(instanceNames[i])
你要的基本上都在里面了，我就不具体实现了

补充：如果你要再页面上使用，读取客户端机器的信息，需要封装成ActiveX或者COM

9. 如何用java 5分钟实现一个最简单的mysql代理服务器

如何用java 5分钟实现一个最简单的mysql代理服务器
首先，准备开发工具套件，我们并不会引入过多工具包，仅仅需要：
java8
vert.x 3
如果你是用maven做为项目管理工具，请将vert.x 3引入：

1
2
3
4
5

<dependency>

<groupId>io.vertx</groupId>

<artifactId>vertx-core</artifactId>

<version>3.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();