org.hibernate.exception.JDBCConnectionException: Cannot open connection
OperateDatabase.java queryAll(String hql)查询结果出来啦
at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:97)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:52)
at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:449)
at org.hibernate.jdbc.ConnectionManager.getConnection(ConnectionManager.java:167)
at org.hibernate.jdbc.AbstractBatcher.prepareQueryStatement(AbstractBatcher.java:161)
at org.hibernate.loader.Loader.prepareQueryStatement(Loader.java:1577)
at org.hibernate.loader.Loader.doQuery(Loader.java:696)
at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:259)
at org.hibernate.loader.Loader.doList(Loader.java:2232)
at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2129)
at org.hibernate.loader.Loader.list(Loader.java:2124)
at org.hibernate.loader.custom.CustomLoader.list(CustomLoader.java:312)
at org.hibernate.impl.SessionImpl.listCustomQuery(SessionImpl.java:1723)
at org.hibernate.impl.AbstractSessionImpl.list(AbstractSessionImpl.java:165)
at org.hibernate.impl.SQLQueryImpl.list(SQLQueryImpl.java:175)
at hibernate.OperateDatabase.querySql(OperateDatabase.java:128)
at socket.Server$1.run(Server.java:225)
at java.lang.Thread.run(Unknown Source)
Caused by: java.sql.SQLException: Data source rejected establishment of connection, message from server: "Too many connections"
at com.mysql.jdbc.MysqlIO.doHandshake(MysqlIO.java:1018)
at com.mysql.jdbc.Connection.createNewIO(Connection.java:2568)
at com.mysql.jdbc.Connection.(Connection.java:1485)
at com.mysql.jdbc.NonRegisteringDriver.connect(NonRegisteringDriver.java:266)
at java.sql.DriverManager.getConnection(Unknown Source)
at java.sql.DriverManager.getConnection(Unknown Source)
at org.hibernate.connection.DriverManagerConnectionProvider.getConnection(DriverManagerConnectionProvider.java:133)
at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:446)
... 15 more
Exception in thread "Thread-27" java.lang.NullPointerException
at socket.Server$1.run(Server.java:226)
at java.lang.Thread.run(Unknown Source)
ClientThread.java线程睡眠1000毫秒=1秒
ClientThread.java从客户端发来的聊天内容：{"actiontype":"1","receverName":"192.168.0.107","msgType":false,"senderName":"192.168.0.108","chatDate":"2017-03-03 18:21:08"}
ClientThread.java动作类型1
Exception in thread "Thread-25" org.hibernate.exception.JDBCConnectionException: Cannot open connection
at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:97)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:52)
at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:449)
at org.hibernate.jdbc.ConnectionManager.getConnection(ConnectionManager.java:167)
at org.hibernate.jdbc.AbstractBatcher.prepareQueryStatement(AbstractBatcher.java:161)
at org.hibernate.loader.Loader.prepareQueryStatement(Loader.java:1577)
at org.hibernate.loader.Loader.doQuery(Loader.java:696)
at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:259)
at org.hibernate.loader.Loader.doList(Loader.java:2232)
at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2129)
at org.hibernate.loader.Loader.list(Loader.java:2124)
at org.hibernate.loader.hql.QueryLoader.list(QueryLoader.java:401)
at org.hibernate.hql.ast.QueryTranslatorImpl.list(QueryTranslatorImpl.java:363)
at org.hibernate.engine.query.HQLQueryPlan.performList(HQLQueryPlan.java:196)
at org.hibernate.impl.SessionImpl.list(SessionImpl.java:1149)
at org.hibernate.impl.QueryImpl.list(QueryImpl.java:102)
at hibernate.OperateDatabase.query(OperateDatabase.java:87)
at chat.ClientThread.run(ClientThread.java:111)
Caused by: java.sql.SQLException: Data source rejected establishment of connection, message from server: "Too many connections"
at com.mysql.jdbc.MysqlIO.doHandshake(MysqlIO.java:1018)
at com.mysql.jdbc.Connection.createNewIO(Connection.java:2568)
at com.mysql.jdbc.Connection.(Connection.java:1485)
at com.mysql.jdbc.NonRegisteringDriver.connect(NonRegisteringDriver.java:266)
at java.sql.DriverManager.getConnection(Unknown Source)
at java.sql.DriverManager.getConnection(Unknown Source)
at org.hibernate.connection.DriverManagerConnectionProvider.getConnection(DriverManagerConnectionProvider.java:133)
at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:446)
... 15 more
hibernate.hbm.xml文件内容，注释部分是连接池，但貌似使用也不管事
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<!-- mysql 数据库驱动 -->
com.mysql.jdbc.Driver
<!-- mysql 数据库名 myandroid 端口3306 -->
jdbc:mysql://localhost:3306/myandroid?useUnicode=true&characterEncoding=utf-8
<!-- 数据的登录用户名 -->
root
<!-- 数据库的登录秘密 -->
admin
<!-- 下面这一行很重要， 如果hibernate.connection.provider_class没有定义,就会使用内置的连接池，所以如果不想用hibernate内置的连接池，下面这一行必须要写的 -->
<!-- 方言：为每一种数据库提供适配器，方便转换 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 2，其他配置 -->
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<!-- 所有的表映射XML文件必须在此录入 导入映射文件-->
<mapping resource="hibernate/Customer.hbm.xml"/>
<mapping resource="hibernate/ChatLog.hbm.xml"/>
<mapping resource="hibernate/ChatMessage.hbm.xml"/>
<mapping resource="hibernate/Pitch.hbm.xml"/>
</session-factory>
补充下，实际是两台安卓手机java 安卓客户端在通过台式电脑服务端 tomcat+hibernate +mysql进行聊天通讯 ，两台手机能正常聊一会，但过十几分钟左右服务器就会报错，或许需要用到连接池 但不太会用，望高人指点
http://blog.csdn.net/zhuying_linux/article/details/7810752
http://blog.csdn.net/new_aiden/article/details/50971016
你要检查你的客户端有没有释放对应的连接，不要不停地建立连接但是用完没有释放数据库连接
服务端另一个java
package chat;
import java.net.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import hibernate.ChatLog;
import hibernate.ChatMessage;
import hibernate.OperateDatabase;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import java.io.*;
public class ClientChatInsertThread extends Thread
{
/**
* 维持服务器与单个客户端的连接线程，负责接收客户端发来的信息,
* 声明一个新的Socket对象，
* 用于保存服务器端用accept方法得到的客户端的连接
**/
Socket clientSocket;
//声明服务器端中存储的Socket对象的数据输入／输出流
DataInputStream in = null;
DataOutputStream out = null;
String message;
String actionType;
String senderName;
String receverName;
JSONObject demoJson;
ClientThread clientThread;
public ClientChatInsertThread(Socket socket,ClientThread clientThread)
{
clientSocket=socket;
this.clientThread=clientThread;
try
{
//创建服务器端数据输入／输出流
in = new DataInputStream(clientSocket.getInputStream());
out = new DataOutputStream(clientSocket.getOutputStream());
}
catch (IOException e2)
{
System.out.println("ClientChatInsertThread.java发生异常"+e2);
System.out.println("ClientChatInsertThread.java建立I/O通道失败！");
System.exit(3);
}
}
//该方法监听该连接对应得客户端是否有消息发送
public void run()
{
OperateDatabase operateDatabase=new OperateDatabase();
while(true)
{
//判断客户端是否关闭
try {
clientSocket.sendUrgentData(0);
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("ClientChatInsertThread.java如果客户端已经退出连接则终止线程循环"+this.getName());
e.printStackTrace();
break;
}
try {
Thread.sleep(7000);
System.out.println("ClientChatInsertThread.java线程睡眠7000毫秒=7秒 ");
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try
{
if(in.available()!=0)//判断输入流是否存在数据也就是有没有数据，如果输入流有数据，则读取
{
message=in.readUTF();
System.out.println("ClientChatInsertThread.java输入流里有了数据");
}
else
{
System.out.println("ClientChatInsertThread.java输入流里没有数据，继续线程内循环等待。。。。");
continue;//继续while循环等待
}
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("ClientChatInsertThread.java从客户端发来的聊天内容1："+message);
//从json中解析出登录用户名和密码，并准备和数据库中用户进行比对
demoJson =JSONObject.fromObject(message);
actionType=demoJson.getString("actiontype");//这个返回的是数字012345.。。等，每一个数字代表一个动作，比如0代表客户单注册客户信息，1.。。。
//从json中解析数据
senderName=demoJson.getString("senderName");//发信人姓名
receverName=demoJson.getString("receverName");//收信人姓名
//开始执行数据库操作
System.out.println("ClientChatInsertThread.java动作类型"+actionType);
if(actionType.equals("2"))
{
String sendTime=demoJson.getString("chatDate");//发送聊天信息的时间
String msgType=demoJson.getString("msgType");
String chatContent=demoJson.getString("chatContent");//聊天内容
//String clientIp=demoJson.getString("clientIp");//客户端IP
//int clientPort=demoJson.getInt("clientPort");//客户端端口号
//号称生成全球唯一的标识
UUID uuid=UUID.randomUUID();
String messageId=uuid.toString();
System.out.println("ClientChatInsertThread.java全球唯一的UUID"+messageId);
//将数据插入到聊天信息记录表和聊天信息表,登录信息表
//聊天记录数据
ChatLog chatLog=new ChatLog();
chatLog.setSenderName(senderName);
chatLog.setReceverName(receverName);
chatLog.setSendTime(sendTime);
chatLog.setMessageId(messageId);
//聊天信息数据
ChatMessage chatMessage=new ChatMessage();
chatMessage.setMessageId(messageId);
chatMessage.setChatMessage(chatContent);
//插入到聊天记录表
operateDatabase.insert(chatLog);
//插入到聊天信息表
operateDatabase.insert(chatMessage);
}
else
{
continue;
}
}
}//end run()
} //end class
服务端
package chat;
import java.net.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import hibernate.ChatLog;
import hibernate.ChatMessage;
import hibernate.OperateDatabase;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import java.io.*;
public class ClientThread extends Thread
{
/**
* 维持服务器与单个客户端的连接线程，负责接收客户端发来的信息,
* 声明一个新的Socket对象，
* 用于保存服务器端用accept方法得到的客户端的连接
**/
Socket clientSocket;
//声明服务器端中存储的Socket对象的数据输入／输出流
DataInputStream in = null;
DataOutputStream out = null;
String message;
String actionType;
String senderName;
String receverName;
JSONObject demoJson;
//声明ServerThread对象
ServerThread serverThread;
ClientChatInsertThread clientChatInsertThread;
public ClientThread(Socket socket,ServerThread serverThread)
{
clientSocket=socket;
this.serverThread=serverThread;
clientChatInsertThread = new ClientChatInsertThread(clientSocket, this); //this 代表当前类
clientChatInsertThread.start(); //客户端插入线程启动
try
{
//创建服务器端数据输入／输出流
in = new DataInputStream(clientSocket.getInputStream());
out = new DataOutputStream(clientSocket.getOutputStream());
}
catch (IOException e2)
{
System.out.println("ClientThread.java发生异常"+e2);
System.out.println("ClientThread.java建立I/O通道失败！");
}
}
//该方法监听该连接对应得客户端是否有消息发送
public void run()
{
try {
message=in.readUTF();
System.out.println("ClientThread.java输入流里有了数据"+message);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
OperateDatabase operateDatabase=new OperateDatabase();
while(true)
{
//判断客户端是否关闭
try {
clientSocket.sendUrgentData(0);
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("ClientThread.java如果客户端已经退出连接则终止线程循环"+this.getName());
e.printStackTrace();
break;
}
System.out.println("ClientThread.java这个线程应该循环 \r");
try {
Thread.sleep(6000);
System.out.println("ClientThread.java线程睡眠1000毫秒=1秒 ");
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System.out.println("ClientThread.java从客户端发来的聊天内容："+message);
//从json中解析出登录用户名和密码，并准备和数据库中用户进行比对
demoJson =JSONObject.fromObject(message);
actionType=demoJson.getString("actiontype");//这个返回的是数字012345.。。等，每一个数字代表一个动作，比如0代表客户单注册客户信息，1.。。。
//从json中解析数据
senderName=demoJson.getString("senderName");//发信人姓名
receverName=demoJson.getString("receverName");//收信人姓名
//开始执行数据库操作
System.out.println("ClientThread.java动作类型"+actionType);
synchronized(serverThread.messages)
{
//json封装数据
JSONObject jsonObjects=new JSONObject();
//将把给自己回信息的人的聊天记录读出来，注意这个时候条件查询中 发信人和收信人是对调的
String hqlChatLog="from ChatLog where sendername=:receverName and recevername=:senderName";
ChatLog chatLogQuery=new ChatLog();
chatLogQuery.setSenderName(senderName);
chatLogQuery.setReceverName(receverName);
List <Object> listChatLog=operateDatabase.query(chatLogQuery,hqlChatLog);
List<JSONObject> listJsonObjectChatLog=new ArrayList<JSONObject>();
//如果存在聊天记录
if(listChatLog.size()!=0)
{
for(int i=0;i<listChatLog.size();i++)
{
//将object对象直接转换成实体对象就可以
chatLogQuery=(ChatLog)listChatLog.get(i);
JSONObject jsonObject=new JSONObject();
jsonObject.put("id", chatLogQuery.getId());
jsonObject.put("senderName", chatLogQuery.getSenderName());
jsonObject.put("receverName",chatLogQuery.getReceverName());
jsonObject.put("sendTime",chatLogQuery.getSendTime());
//将所有聊天信息读出来
String hqlChatMessage="from ChatMessage where messageid=:messageId";
ChatMessage chatMessageQuery=new ChatMessage();
chatMessageQuery.setMessageId(chatLogQuery.getMessageId());
List<Object> listChatMessage=operateDatabase.query(chatMessageQuery,hqlChatMessage);
for(int j=0;j<listChatMessage.size();j++)
{
ChatMessage chatMessage1=(ChatMessage)listChatMessage.get(j);
jsonObject.put("chatMessage",chatMessage1.getChatMessage());//返回聊天信息
System.out.println("聊天信息："+chatMessage1.getChatMessage());
}
listJsonObjectChatLog.add(jsonObject);
}
jsonObjects.put("chatLog",listJsonObjectChatLog);
//将线程名称放到jsonObject对象中，和聊天信息放在一起，为了在发送聊天时比对线程名称
//将线程名称放到JSONObject中
jsonObjects.put("threadName", this.getName());//当前线程的名称
//将客户端发送来得信息存于serverThread的messages数组中
System.out.println("ClientThread.java准备返回客户端的聊天信息"+jsonObjects);
//将聊天信息存入vector
serverThread.messages.addElement(jsonObjects);
//标记已经发送的聊天信息为已发送或者暂时直接删除已经发送的信息
//删除已经发送过的日志
JSONArray jsonArray=jsonObjects.getJSONArray("chatLog");
ChatLog deleteChatLog=new ChatLog();
JSONObject jsonObjectDelete=new JSONObject();
for(int i=0;i<jsonArray.size();i++)
{
jsonObjectDelete=jsonArray.getJSONObject(i);
deleteChatLog.setId(jsonObjectDelete.getString("id"));
operateDatabase.delete(deleteChatLog);//删除方法是按照主键删除的，你这样是删除不了信息的
System.out.println("ClientThread.java从MYSQL数据库中删除了一条聊天记录");
}
}//如果存在聊天记录if(listChatLog.size()!=0)
}//synchronized同步
}//end while(true)
}//end run()
} //end class
数据库操作java
package hibernate;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OperateDatabase {
private Configuration configuration=null;
private static final Logger logger=LoggerFactory.getLogger(OperateDatabase.class);
public OperateDatabase() {
// TODO Auto-generated constructor stub
//读取hibernate.cfg.xml文件
configuration=new Configuration().configure();
logger.info("用org.slf4j.Logger来执行日志跟踪。操作数据库开始");
System.out.println("OperateDatabase开始操作数据库了了");
}
/*
* 插入数据库操作，对象传递数据
*/
public void insert(Object object)
{
//读取hibernate.cfg.xml文件
//Configuration configuration=new Configuration().configure();
//实例 session工厂 sessionFactory
SessionFactory sessionFactory=configuration.buildSessionFactory();
//打开session
Session session=null;
Transaction tranaction=null;
try
{
session=sessionFactory.openSession();
//开启事务，确保操作成功与否，成功则执行提交，执行对库操作，失败则执行回滚操作不执行对库操作
tranaction=session.beginTransaction();
// 执行插入数据库操作
session.save(object);
//提交事务
tranaction.commit();
}
catch(Exception e)
{
e.printStackTrace();
//如果操作失败一定要做事务回滚操作
tranaction.rollback();
}
finally
{
if(session!=null)
{
if(session.isOpen())
{
session.close();
}
}
//无论数据库操作成功与否都要及时关闭session ,以便释放资源，实际上关闭的目的都应该是释放资源吧最终
}
}
/**
*
* @param object 与实体对象可以直接转换，比如：List <Object> listChatLog=operateDatabase.query(chatLogQuery,hqlChatLog); chatLogQuery=(ChatLog)listChatLog.get(i);
* @param hql 格式如：String hqlChatLog="from ChatLog where sendername=:senderName and recevername=:receverName";
* (用"：命名"占位符，用setProperties设值,命名参数必须要与被绑定的属性名相同)
* @return
*/
public List<Object> query(Object object,String hql)
{
//读取hibernate.hbm.xml 文件，默认在 工程的src目录下
//Configuration configuration=new Configuration().configure();
SessionFactory sessionFactory=configuration.buildSessionFactory();
Session session=null;
List<Object> list=null;
session=sessionFactory.openSession();
//执行查询，返回 list数组
Query query=session.createQuery(hql);
query.setProperties(object);
list=query.list();
session.close();
//无论数据库操作成功与否必须关闭session
if(session!=null)
{
if(session.isOpen())
{
session.close();
}
}
return list;
}
/**
* 用sql语句进行去重复查询，为使用对象查询
* @param sql
* @return
*/
public List<Object> querySql(String sql)
{
//建立session工厂
SessionFactory sessionFactory =configuration.buildSessionFactory();
//实例session
Session session=null;
//实例List object对象数组
List<Object> list=null;
try
{
//打开session
session=sessionFactory.openSession();
//根据hql进行查询，例如hql=" from ObjectA" 。其中ObjectA 是 表映射的实体类
//注意 执行查询操作不需要开启事务。。。。。
list=session.createSQLQuery(sql).list();//注意这里没有使用createQuery的hql查询方法
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
session.close();
}
//关闭session
System.out.println("OperateDatabase.java queryAll(String hql)查询结果出来啦");
return list;
}
/**
*
* @param hql 例如hql="from Person" 。其中Person 是表对应的实例类
* @return 返回任意一个表的所有数据
*/
public List<Object> queryAll(String hql)
{
//建立session工厂
SessionFactory sessionFactory =configuration.buildSessionFactory();
//实例session
Session session=null;
//实例List object对象数组
List<Object> list=null;
try
{
//打开session
session=sessionFactory.openSession();
//根据hql进行查询，例如hql=" from ObjectA" 。其中ObjectA 是 表映射的实体类
//注意 执行查询操作不需要开启事务。。。。。
list=session.createQuery(hql).list();
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
session.close();
}
//关闭session
System.out.println("OperateDatabase.java queryAll(String hql)查询结果出来啦");
return list;
}
public void delete(Object object)
{
//建立session工厂
SessionFactory sessionFactory=configuration.buildSessionFactory();
//初始化session
Session session=null;
Transaction transaction=null;
try
{
//打开session
session=sessionFactory.openSession();
//开始session事务
transaction=session.beginTransaction();
//执行删除操作
session.delete(object);
//提交事务
transaction.commit();
}
catch(Exception e)
{
if(transaction!=null)
{
transaction.rollback();
}
}
finally
{
if(session!=null)
{
if(session.isOpen())
{
session.close();//关闭session
}
}
}
}
public void delete(String hql)
{
SessionFactory sessionFactory=configuration.buildSessionFactory();
Session session=null;
Transaction transaction=null;
try
{
session=sessionFactory.openSession();
transaction=session.beginTransaction();
Query query=session.createSQLQuery(hql);//用createSQLQuery()方法是传统的sql方法，hql语句里的表明和数据库里的表名一致，不和类的名一致
//用createQuery()方法 则 hql的表明和类名一致注意大小写
query.executeUpdate();
transaction.commit();
System.out.println("删除成功"+hql);
}
catch(Exception e)
{
if(transaction!=null)
{
transaction.rollback();
// throw e;
}
}
finally
{
if(session!=null)
{
if(session.isOpen())
{
session.close();//关闭session
}
}
}
}
}
nobody can help my???