Решил посмотреть топ сурс, специально для этого раздела с этой шары [Epilogue] Rastprguev top developer share source Jan 2k15
Гавнокод в работе, а удалить и выпилить это не судьба наверное особенно и переписать например на java.sql.*
Код:
package l2s.database;
import java.sql.SQLException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import l2s.Config;
import l2s.Server;
import l2s.database.connectingpool.ConnectingPoolDBCP;
import l2s.database.connectingpool.IConnectingPool;
public class L2DatabaseFactory
{
private static L2DatabaseFactory _instance;
private static L2DatabaseFactory _instanceLogin;
private final static Logger _log = Logger.getLogger(L2DatabaseFactory.class.getName());
private final ConcurrentHashMap<String, ThreadConnection> _connections = new ConcurrentHashMap<String, ThreadConnection>();
private IConnectingPool _connection_pool;
public enum ConnectingPoolType
{
DBCP;
}
public L2DatabaseFactory(final String poolName, final String driver, final String url, final String login, final String pass, final int poolSize, final int idleTimeOut, final int idleTestPeriod) throws SQLException
{
switch (Config.DATABASE_TYPE_CONNECTING_POOL)
{
case DBCP:
_connection_pool = new ConnectingPoolDBCP(poolName, driver, url, login, pass, poolSize, idleTimeOut, idleTestPeriod);
break;
default:
{
Server.exit(0, "L2DatabaseFactory: wrong type connecting pool!");
}
}
}
public static L2DatabaseFactory getInstance() throws SQLException
{
if(_instance == null)
{
_instance = new L2DatabaseFactory("GameServer", Config.DATABASE_DRIVER, Config.DATABASE_URL, Config.DATABASE_LOGIN, Config.DATABASE_PASSWORD, Config.DATABASE_MAX_CONNECTIONS, Config.DATABASE_MAX_IDLE_TIMEOUT, Config.DATABASE_IDLE_TEST_PERIOD);
if(Config.DATABASE_URL.equalsIgnoreCase(Config.ACCOUNTS_DATABASE_URL))
_instanceLogin = _instance;
}
return _instance;
}
public static L2DatabaseFactory getInstanceLogin() throws SQLException
{
if(_instanceLogin == null)
{
if(Config.DATABASE_URL.equalsIgnoreCase(Config.ACCOUNTS_DATABASE_URL))
return getInstance();
_instanceLogin = new L2DatabaseFactory("LoginServer", Config.DATABASE_DRIVER, Config.ACCOUNTS_DATABASE_URL, Config.ACCOUNTS_DATABASE_LOGIN, Config.ACCOUNTS_DATABASE_PASSWORD, 2, Config.DATABASE_MAX_IDLE_TIMEOUT, Config.DATABASE_IDLE_TEST_PERIOD);
}
return _instanceLogin;
}
public ThreadConnection getConnection() throws SQLException
{
ThreadConnection connection;
if(Config.USE_DATABASE_LAYER)
{
final String key = generateKey();
connection = _connections.get(key);
if(connection == null)
try
{
connection = new ThreadConnection(_connection_pool.getConnection(), this);
}
catch(final SQLException e)
{
_log.warning("Couldn't create connection. Cause: " + e.getMessage());
}
else
connection.updateCounter();
if(connection != null)
synchronized (_connections)
{
_connections.put(key, connection);
}
}
else
connection = new ThreadConnection(_connection_pool.getConnection(), this);
return connection;
}
public ConcurrentHashMap<String, ThreadConnection> getConnections()
{
return _connections;
}
public void shutdown()
{
_connections.clear();
try
{
_connection_pool.shutdown();
_connection_pool = null;
}
catch(final Exception e)
{
_log.log(Level.WARNING, "", e);
}
}
public String generateKey()
{
return String.valueOf(Thread.currentThread().hashCode());
}
public String getStats()
{
return _connection_pool.getStats();
}
}
Код:
package l2s.database;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
public class FiltredPreparedStatement implements FiltredStatementInterface
{
private transient final PreparedStatement myStatement;
public FiltredPreparedStatement(final PreparedStatement statement)
{
myStatement = statement;
}
public ResultSet executeQuery() throws SQLException
{
return myStatement.executeQuery();
}
public void close()
{
try
{
myStatement.close();
}
catch(final SQLException e)
{
e.printStackTrace();
}
}
public boolean execute() throws SQLException
{
return myStatement.execute();
}
public ResultSet executeQuery(final String sql) throws SQLException
{
return myStatement.executeQuery(sql);
}
public void setInt(final int index, final int val) throws SQLException
{
myStatement.setInt(index, val);
}
public void setString(final int index, final String val) throws SQLException
{
myStatement.setString(index, val);
}
public void setLong(final int index, final long val) throws SQLException
{
myStatement.setLong(index, val);
}
public void setNull(final int index, final int val) throws SQLException
{
myStatement.setNull(index, val);
}
public void setDouble(final int index, final double val) throws SQLException
{
myStatement.setDouble(index, val);
}
public void setBytes(final int index, final byte[] data) throws SQLException
{
myStatement.setBytes(index, data);
}
public int executeUpdate() throws SQLException
{
return myStatement.executeUpdate();
}
public void setBoolean(final int index, final boolean val) throws SQLException
{
myStatement.setBoolean(index, val);
}
public void setEscapeProcessing(final boolean val) throws SQLException
{
myStatement.setEscapeProcessing(val);
}
public void setByte(final int index, final byte val) throws SQLException
{
myStatement.setByte(index, val);
}
public void setDate(final int index, final Date value) throws SQLException
{
myStatement.setDate(index, value);
}
public void setTimestamp(final int index, final Timestamp timestamp) throws SQLException
{
myStatement.setTimestamp(index, timestamp);
}
public ResultSet getGeneratedKeys() throws SQLException
{
return myStatement.getGeneratedKeys();
}
public void setVars(final Object... vars) throws SQLException
{
Number n;
long long_val;
double double_val;
for(int i = 0; i < vars.length; i++)
if(vars[i] instanceof Number)
{
n = (Number) vars[i];
long_val = n.longValue();
double_val = n.doubleValue();
if(long_val == double_val)
setLong(i + 1, long_val);
else
setDouble(i + 1, double_val);
}
else if(vars[i] instanceof String)
setString(i + 1, (String) vars[i]);
}
}package l2s.database;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class FiltredStatement implements FiltredStatementInterface
{
private final Statement myStatement;
public FiltredStatement(final Statement statement)
{
myStatement = statement;
}
public int executeUpdate(final String sql) throws SQLException
{
return myStatement.executeUpdate(sql);
}
public void close()
{
try
{
myStatement.close();
}
catch(final SQLException e)
{
e.printStackTrace();
}
}
public void addBatch(final String sql) throws SQLException
{
myStatement.addBatch(sql);
}
public int[] executeBatch() throws SQLException
{
return myStatement.executeBatch();
}
public ResultSet executeQuery(final String sql) throws SQLException
{
return myStatement.executeQuery(sql);
}
}
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class FiltredStatement implements FiltredStatementInterface
{
private final Statement myStatement;
public FiltredStatement(final Statement statement)
{
myStatement = statement;
}
public int executeUpdate(final String sql) throws SQLException
{
return myStatement.executeUpdate(sql);
}
public void close()
{
try
{
myStatement.close();
}
catch(final SQLException e)
{
e.printStackTrace();
}
}
public void addBatch(final String sql) throws SQLException
{
myStatement.addBatch(sql);
}
public int[] executeBatch() throws SQLException
{
return myStatement.executeBatch();
}
public ResultSet executeQuery(final String sql) throws SQLException
{
return myStatement.executeQuery(sql);
}
}
Код:
package l2s.database;
public interface FiltredStatementInterface
{
public void close();
}
Код:
package l2s.database;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.logging.Logger;
public class ThreadConnection
{
private final static Logger _log = Logger.getLogger(ThreadConnection.class.getName());
private transient final Connection myConnection;
private final L2DatabaseFactory myFactory;
private int counter = 1;
public ThreadConnection(final Connection con, final L2DatabaseFactory f)
{
myConnection = con;
myFactory = f;
}
public void updateCounter()
{
counter++;
}
public FiltredPreparedStatement prepareStatement(final String sql) throws SQLException
{
return new FiltredPreparedStatement(myConnection.prepareStatement(sql));
}
public FiltredPreparedStatement prepareStatement(final String sql, final int Statement) throws SQLException
{
return new FiltredPreparedStatement(myConnection.prepareStatement(sql, Statement));
}
public void close()
{
counter--;
if(counter == 0)
try
{
synchronized (myFactory.getConnections())
{
myConnection.close();
final String key = myFactory.generateKey();
myFactory.getConnections().remove(key);
}
}
catch(final Exception e)
{
_log.warning("Couldn't close connection. Cause: " + e.getMessage());
}
}
public FiltredStatement createStatement() throws SQLException
{
return new FiltredStatement(myConnection.createStatement());
}
}
Код:
package l2s.database.utils;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import l2s.Config;
import l2s.commons.text.Strings;
import l2s.database.FiltredStatement;
import l2s.database.FiltredStatementInterface;
import l2s.database.L2DatabaseFactory;
import l2s.database.ThreadConnection;
public class DbUtils
{
private static final Logger _log = Logger.getLogger(DbUtils.class.getName());
public static String mysql_server_version = null;
public static String getMySqlServerVersion()
{
if(mysql_server_version != null)
return mysql_server_version;
ThreadConnection con = null;
FiltredStatement statement = null;
ResultSet rs = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection();
statement = con.createStatement();
rs = statement.executeQuery("SELECT VERSION() AS mysql_version");
rs.next();
mysql_server_version = rs.getString("mysql_version");
}
catch(final Exception e)
{
_log.log(Level.WARNING, "DbUtils: getMySqlServerVersion error: ", e);
mysql_server_version = "UNKNOW";
}
finally
{
DbUtils.closeQuietly(con, statement, rs);
}
return mysql_server_version;
}
public static void optimizeTables()
{
if(!Config.ALLOW_OPTIMIZE_TABLES)
return;
ThreadConnection con = null;
FiltredStatement st = null;
ResultSet rs = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection();
st = con.createStatement();;
final ArrayList<String> tablesList = new ArrayList<String>();
rs = st.executeQuery("SHOW FULL TABLES");
while (rs.next())
{
final String tableType = rs.getString(2/* "Table_type" */);
if(tableType.equals("VIEW"))
continue;
tablesList.add(rs.getString(1));
}
rs.close();
final String all_tables = Strings.joinStrings(",", tablesList.toArray(new String[tablesList.size()]));
rs = st.executeQuery("CHECK TABLE " + all_tables);
while (rs.next())
{
final String table = rs.getString("Table");
final String msgType = rs.getString("Msg_type");
final String msgText = rs.getString("Msg_text");
if(msgType.equals("status"))
if(msgText.equals("OK"))
continue;
_log.log(Level.WARNING, "DbUtils: CHECK TABLE " + table + ": " + msgType + " -> " + msgText);
}
rs.close();
_log.info("DbUtils: Database tables have been checked.");
rs = st.executeQuery("ANALYZE TABLE " + all_tables);
while (rs.next())
{
final String table = rs.getString("Table");
final String msgType = rs.getString("Msg_type");
final String msgText = rs.getString("Msg_text");
if(msgType.equals("status"))
if(msgText.equals("OK") || msgText.equals("Table is already up to date"))
continue;
if(msgType.equals("note"))
if(msgText.equals("The storage engine for the table doesn't support analyze"))
continue;
_log.log(Level.WARNING, "DbUtils: ANALYZE TABLE " + table + ": " + msgType + " -> " + msgText);
}
rs.close();
_log.info("DbUtils: Database tables have been analyzed.");
rs = st.executeQuery("OPTIMIZE TABLE " + all_tables);
while (rs.next())
{
final String table = rs.getString("Table");
final String msgType = rs.getString("Msg_type");
final String msgText = rs.getString("Msg_text");
if(msgType.equals("status"))
if(msgText.equals("OK") || msgText.equals("Table is already up to date"))
continue;
if(msgType.equals("note"))
if(msgText.equals("Table does not support optimize, doing recreate + analyze instead"))
continue;
_log.log(Level.WARNING, "DbUtils: OPTIMIZE TABLE " + table + ": " + msgType + " -> " + msgText);
}
_log.info("DbUtils: Database tables have been optimized.");
}
catch(final Exception e)
{
_log.log(Level.WARNING, "DbUtils: Cannot optimize database tables!", e);
}
finally
{
closeQuietly(con, st, rs);
}
}
public static void closeDatabaseCSR(ThreadConnection conn, FiltredStatementInterface stmt, ResultSet rs)
{
closeResultSet(rs);
closeStatement(stmt);
closeConnection(conn);
}
public static void closeResultSet(ResultSet rs)
{
if(rs != null)
try
{
rs.close();
}
catch(SQLException e)
{}
}
public static void closeStatement(FiltredStatementInterface stmt)
{
if(stmt != null)
stmt.close();
}
public static void closeConnection(ThreadConnection conn)
{
if(conn != null)
conn.close();
}
public static void repairTables()
{
if(!Config.ALLOW_REPAIR_TABLES)
return;
ThreadConnection con = null;
FiltredStatement st = null;
ResultSet rs = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection();
st = con.createStatement();;
final ArrayList<String> tablesList = new ArrayList<String>();
rs = st.executeQuery("SHOW FULL TABLES");
while (rs.next())
{
final String tableType = rs.getString(2/* "Table_type" */);
if(tableType.equals("VIEW"))
continue;
tablesList.add(rs.getString(1));
}
rs.close();
final String all_tables = Strings.joinStrings(",", tablesList.toArray(new String[tablesList.size()]));
rs = st.executeQuery("REPAIR TABLE " + all_tables + " EXTENDED");
while (rs.next())
{
final String table = rs.getString("Table");
final String msgType = rs.getString("Msg_type");
final String msgText = rs.getString("Msg_text");
if(msgType.equals("status"))
if(msgText.equals("OK"))
continue;
if(msgType.equals("note"))
if(msgText.equals("The storage engine for the table doesn't support repair"))
continue;
_log.log(Level.WARNING, "DbUtils: REPAIR TABLE " + table + ": " + msgType + " -> " + msgText);
}
_log.info("DbUtils: Database tables have been repaired.");
}
catch(final Exception e)
{
_log.log(Level.WARNING, "DbUtils: Cannot optimize database tables!", e);
}
finally
{
closeQuietly(con, st, rs);
}
}
public static void close(final ThreadConnection conn)
{
if(conn == null)
return;
conn.close();
}
public static void close(final ResultSet rs)
{
if(rs == null)
return;
try
{
rs.close();
}
catch(final SQLException e)
{
_log.log(Level.WARNING, "Failed to close ResultSet!", e);
}
}
public static void close(final FiltredStatementInterface stmt)
{
if(stmt == null)
return;
stmt.close();
}
public static void close(final FiltredStatementInterface stmt, final ResultSet rs)
{
close(rs);
close(stmt);
}
public static void closeQuietly(final ThreadConnection conn)
{
close(conn);
}
public static void closeQuietly(final ResultSet rs)
{
close(rs);
}
public static void closeQuietly(final FiltredStatementInterface stmt)
{
close(stmt);
}
public static void closeQuietly(final ThreadConnection conn, final FiltredStatementInterface stmt)
{
closeQuietly(stmt);
closeQuietly(conn);
}
public static void closeQuietly(final FiltredStatementInterface stmt, final ResultSet rs)
{
closeQuietly(rs);
closeQuietly(stmt);
}
public static void closeQuietly(final ThreadConnection conn, final FiltredStatementInterface stmt, final ResultSet rs)
{
closeQuietly(rs);
closeQuietly(stmt);
closeQuietly(conn);
}
}
