java服务器启动mysql,服务器的启动

本文目录一览：

1、java怎么连接mysql数据库
2、如何用java开启mysql事务，要求详细
3、JAVA连mysql
4、如何用java 5分钟实现一个最简单的mysql代理服务器
5、java中怎么连接mysql数据库

java怎么连接mysql数据库

java 连接 mysql 和连接oracle 是相同的

第一步配置驱动

第二步配置数据库服务地址默认端口 3306

第三步打开连接（配置用户和密码）

具体代码如下：

String url = “jdbc:mysql://localhost:3306/javademo?user=rootpassword=rootuseUnicode=truecharacterEncoding=UTF8”;

Class.forName(“com.mysql.jdbc.Driver”);// 动态加载mysql驱动

conn = DriverManager.getConnection(url);

Statement stmt = conn.createStatement();

如何用java开启mysql事务，要求详细

看你是什么事务，jdbc事务，还是分布式事务，还是容器事务

1，编程式事务管理（jdbc的事务是绑定在connection上的）

Connection conn = null;

try

{

Class.forName(“com.mysql.jdbc.Driver”);

conn = DriverManager.getConnection(“jdbc:oracle:thin:@host:1521:SID”,”username”,”password”);

conn.setAutoCommit(false); //取消自动提交

PreparedStatement ps = conn.prepareCall(“update something”);

ResultSet rs = ps.executeQuery();

conn.commit(); //手动提交

}

catch (Exception e)

{

conn.rollback();

e.printStackTrace();

}

finally

{

conn.close();

}

2，声明式事务

先在工程的application.xml配置文件中添加如下代码，开启事务

!– 声明式事务控制配置 —

tx:annotation-driven transaction-manager=”txManager”/

bean id=”txManager” class=”org.springframework.jdbc.datasource.DataSourceTransactionManager”

property name=”datasource” ref=”bassDataSource”/property

/bean

然后在你需要开启事务的接口前面添加注解

@Transactional(rollbackFor = IOException.class)

public void add(String name) throws IOException

{

System.out.println(“可以再类里和方法里面添加事务注解0~0”);

throw new IOException();

}

直接调用接口方法就好

分布式事务处理（mysql貌似在5.X之后才支持）的话，

1.可以直接使用spring+atomikos框架进行管理

参考：

就不贴测试代码了，自己看着配置吧

2，使用JTA（Java Transaction API）进行分布式事务管理（测试代码如下）

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;

import javax.naming.InitialContext;

import javax.sql.DataSource;

import javax.transaction.SystemException;

import javax.transaction.UserTransaction;

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

//分布式事务处理

public class transferAccount

{

@SuppressWarnings(“null”)

public void testTransferAccount()

{

JAVA连mysql

查看了Mysql的文档，以及Connector/J的文档以及在线说明发现，出现这种异常的原因是：Mysql服务器默认的“wait_timeout”是8小时，也就是说一个connection空闲超过8个小时，Mysql将自动断开该 connection。这就是问题的所在，在C3P0 pools中的connections如果空闲超过8小时，Mysql将其断开，而C3P0并不知道该connection已经失效，如果这时有 Client请求connection，C3P0将该失效的Connection提供给Client，将会造成上面的异常。

上网搜索，在MySQL的论坛上找到一个办法，就是如果在执行sql语句的时候发生了上述异常，就将sql语句重新执行一次。

试验发现，这个办法对这个使用spring+hibernate的服务无效。

进一步搜索发现，MySQL官方不推荐使用autoReconnect=true，参见

需要另外找别的办法来解决这个问题。

由于问题产生的根本原因在于服务到数据库的连接长时间没活动，既然重新连接的办法无效，就可以尝试另外一种办法，就是反空闲。

自己写一个线程来反空闲的话，比较麻烦。

最后在网上找到一个办法。为hibernate配置连接池，推荐用c3p0，然后配置c3p0的反空闲设置idle_test_period，只要小于MySQL的wait timeout即可。

在hibernate.cfg.xml中增加下面几项：

!– configuration pool via c3p0–

property name=”hibernate.connection.provider_class”org.hibernate.connection.C3P0ConnectionProvider/property

property name=”c3p0.min_size”5/property

property name=”c3p0.max_size”30/property

property name=”c3p0.time_out”1800/property !– seconds –!– default: 0 —

property name=”c3p0.max_statement”50/property !– default: 0 —

property name=”c3p0.acquire_increment”1/property !– default: 1 —

property name=”c3p0.idle_test_period”120/property !– seconds –!– default: 0 —

property name=”c3p0.validate”true/property

修改完后测试，问题解决。

——————————————————–

DBCP连接池说明:

driverClassName

url

username

password

上面四个分别是驱动,连接字符串,用户名和密码

maxActive 连接池支持的最大连接数

maxIdle 连接池中最多可空闲maxIdle个连接

minIdle 连接池中最少空闲maxIdle个连接

initialSize 初始化连接数目

maxWait 连接池中连接用完时,新的请求等待时间,毫秒

timeBetweenEvictionRunsMillis timeBetweenEvictionRunsMillis和minEvictableIdleTimeMillis一起使用,每

timeBetweenEvictionRunsMillis毫秒秒检查一次连接池中空闲的连接,把空闲时间超过minEvictableIdleTimeMillis毫秒的连接断开,直到连接池中的连接数到minIdle为止

minEvictableIdleTimeMillis 连接池中连接可空闲的时间,毫秒

removeAbandoned true,false,是否清理removeAbandonedTimeout秒没有使用的活动连接,清理后并没有放回连接池

removeAbandonedTimeout 活动连接的最大空闲时间

logAbandoned true,false,连接池收回空闲的活动连接时是否打印消息

minEvictableIdleTimeMillis,removeAbandonedTimeout这两个参数针对的连接对象不一样,minEvictableIdleTimeMillis针对连接池中的连接对象,removeAbandonedTimeout针对未被close的活动连接.

c3p0连接池说明:

driverClass

jdbcUrl

user

password

minPoolSize

maxPoolSize

initialPoolSize

acquireIncrement 池中没有空闲连接时,一次请求获取的连接数

maxIdleTime 池中连接最大空闲时间

acquireRetryAttempts 获取连接失败后,重新尝试的次数

acquireRetryDelay 尝试连接间隔时间,毫秒

checkoutTimeout 等待连接时间,0为无限等待,毫秒

DebugUnreturnedConnectionStackTraces true,false,是否收回未返回的活动连接

unreturnedConnectionTimeout 活动连接的时间.

jdbcurl建议不要使用autoReconnect=true。

———————————————————————-

session.close();没有调用connection.close()吗？

如果你的Connection来自于连接池，他只不过被归还给池了，确实没有物理关闭，这是正常的结果。

若调用connection.close(), 此连接对象是关闭，还是没有关闭，只返回给了连接池 ?

那要看连接池的实现了。一般都是返回给连接池，因为新建连接的开销太大了。

创建一个SessionFactry就对应一个Connection,面SessionFactory中的Session是共享Connection .所以关闭Session对Connection没有影响的.

数据库连结池不过就是一个特殊的对象池而已。对象池的作用就是避免你直接new资源性的对象，降低开销。把连结返回给连结池就是释放对该对象池中该Connection对象的引用，这样，这个对象可以给再次被别人使用。你调用conn.close()，仅仅是释放了引用而已，不会关闭物理的连接。

connection对像在链接池中复写了close方法，所以并没有真正意义上的关闭。明白了吧。当然不同的链接池有不同的实现方法，connection只是一个接口，不同的链接池实现类是不一样的，只是我们感觉不到罢了。

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

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();

} else {

logger.error(result.cause().getMessage(), result.cause());

socket.close();

}

})).listen(port, listenResult – {//代理服务器的监听端口

if (listenResult.succeeded()) {

//成功启动代理服务器

logger.info(“Mysql proxy server start up.”);

} else {

//启动代理服务器失败

logger.error(“Mysql proxy exit. because: ” + listenResult.cause().getMessage(), listenResult.cause());

System.exit(1);

}

});

}

public static class MysqlProxyConnection {

private final NetSocket clientSocket;

private final NetSocket serverSocket;

public MysqlProxyConnection(NetSocket clientSocket, NetSocket serverSocket) {

this.clientSocket = clientSocket;

this.serverSocket = serverSocket;

}

private void proxy() {

//当代理与mysql服务器连接关闭时，关闭client与代理的连接

serverSocket.closeHandler(v – clientSocket.close());

//反之亦然

clientSocket.closeHandler(v – serverSocket.close());

//不管那端的连接出现异常时，关闭两端的连接

serverSocket.exceptionHandler(e – {

logger.error(e.getMessage(), e);

close();

});

clientSocket.exceptionHandler(e – {

logger.error(e.getMessage(), e);

close();

});

//当收到来自客户端的数据包时，转发给mysql目标服务器

clientSocket.handler(buffer – serverSocket.write(buffer));

//当收到来自mysql目标服务器的数据包时，转发给客户端

serverSocket.handler(buffer – clientSocket.write(buffer));

}

private void close() {

clientSocket.close();

serverSocket.close();

}

测试一下

try {

Class.forName(name);//指定连接类型

Connection conn = DriverManager.getConnection(url, user, password);//url为代理服务器的地址

PreparedStatement pst = conn.prepareStatement(“select * from test;”);//准备执行语句

ResultSet resultSet = pst.executeQuery();

while (resultSet.next()) {

System.out.println(resultSet.getLong(1) + “: ” + resultSet.getString(2));

}

} catch (Exception e) {

e.printStackTrace();

}

java中怎么连接mysql数据库

java链接MySQL数据库和链接其他数据库, 基本都是一样的套路

准备工作:

1: 数据库驱动. 导入项目

2: 启动MySQL服务

编码工作:

// 1.注册驱动

Class.forName(“com.mysql.jdbc.Driver”);

// 2.连接数据库

Connection conn = DriverManager.getConnection(DB_URL, NAME, PSWD);

//数据库地址,用户名,密码

// 3.准备执行sql语句

Statement stat = conn.createStatement();

原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/193894.html