1. 首先找一個依賴包比如mysql-connector-java-5.1.39-bin.jar放到WebContent/WEB-INF/lib文件夾下
2 .選擇Project - Properties - Java Build Path - Libraries - Add JARs添加
3 .在項目中新建Package名爲mysql
4. 將下面兩個類添加到mysql包下
package mysql;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Timer;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
public class ConnectionPool {
private String jdbcDriver = "com.mysql.jdbc.Driver"; // 數據庫驅動
private String dbUrl = "jdbc:mysql://localhost:3306/"; // 數據 URL
private String dbUsername = ""; // 數據庫用戶名
private String dbPassword = ""; // 數據庫用戶密碼
private String testTable = ""; // 測試連接是否可用的測試表名，默認沒有測試表
private int initialConnections = 4; // 連接池的初始大小
private int incrementalConnections = 4;// 連接池自動增加的大小
private int maxConnections = 32; // 連接池最大的大小
private int needFreeTime = 1800000;//一個連接多長時間未使用則釋放之，單位毫秒
private int freeCheckTime = 1800000;//多長時間對線程池進行一次不活躍連接回收
//存放連接池中數據庫連接的向量 , 初始時爲 null，它中存放的對象爲 PooledConnection 型
private List<PooledConnection> connections = null;
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private WriteLock wl = lock.writeLock();
private Timer timer = new Timer();
public ConnectionPool(String dbUsername,String dbPassword,String dbName,String testTable) {
this.dbUsername = dbUsername;
this.dbPassword = dbPassword;
dbUrl = dbUrl + dbName;
this.testTable = testTable;
}
/**
*
* 創建一個數據庫連接池，連接池中的可用連接的數量採用類成員 initialConnections 中設置的值
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
* @throws SQLException
*/
public void createPool() throws InstantiationException, IllegalAccessException, ClassNotFoundException, SQLException {
try {
wl.lock();
// 確保連接池沒有創建
// 如果連接池己經創建了，保存連接的向量 connections 不會爲空
if (connections != null) {
return; // 如果己經創建，則返回
}
Class.forName(this.jdbcDriver);
//Tools.log("註冊了jdbc");
// 實例化 JDBC Driver 中指定的驅動類實例
//Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
//DriverManager.registerDriver(driver); // 註冊 JDBC 驅動程序
// 創建保存連接的向量 , 初始時有 0 個元素
connections = new ArrayList<PooledConnection>();
// 根據 initialConnections 中設置的值，創建連接。
createConnections(this.initialConnections);
timer.schedule(new MyTask(),freeCheckTime,freeCheckTime);
}
finally{
wl.unlock();
}
}
class MyTask extends java.util.TimerTask{
@Override
public void run() {
// TODO Auto-generated method stub
// 確保連接池己創新存在
if (connections == null) {
System.out.println(" 連接池不存在，無法刷新 !");
return;
}
List<PooledConnection> dels = new ArrayList<PooledConnection>();
long time0 = System.currentTimeMillis();
int s = 0;
try {
wl.lock();
for(int i=0;i<connections.size();++i){
PooledConnection pConn = connections.get(i);
long time = time0 - pConn.lastTime;
//如果一個連接30分鐘內沒有被使用過，放入回收隊列
if (!pConn.isBusy() && time > needFreeTime) {
dels.add(pConn);
}
}
//保證最少連接數待命
if(connections.size() - dels.size() < initialConnections){
s = initialConnections - connections.size() + dels.size();
}
//釋放多餘長時間未使用連接
for(int i=s; i<dels.size();++i){
closeConnection(dels.get(i).getConnection());
connections.remove(dels.get(i));
}
}
finally{
wl.unlock();
}
/*
StringBuilder sb = new StringBuilder();
sb.append(Tools.getTime(time0));
sb.append("\r\n");
sb.append("現有連接數量:"+connections.size());
sb.append("\r\n");
sb.append("發現長時間未用連接數量:"+dels.size());
sb.append("\r\n");
sb.append("需要釋放連接數量:"+String.valueOf(dels.size()-s)+"\r\n");
sb.append("\r\n\r\n");
EasyFile.appendAllText(EasyFile.getWebInf()+"/cp_log.txt", sb.toString());*/
}
}
public String status()
{
StringBuilder sb = new StringBuilder();
sb.append("總連接數量"+connections.size());
sb.append(" ");
int used = 0;
int free = 0;
for(int i=0;i<connections.size();++i){
PooledConnection pConn = connections.get(i);
if (pConn.isBusy()) {
used++;
}
else{
free++;
}
}
sb.append("正使用"+used);
sb.append(" ; ");
sb.append("未使用"+free);
return sb.toString();
}
/**
* 創建由 numConnections 指定數目的數據庫連接 , 並把這些連接 放入 connections 向量中
*
* @param numConnections
* 要創建的數據庫連接的數目
* @throws SQLException
*/
private void createConnections(int numConnections) throws SQLException{
// 循環創建指定數目的數據庫連接
for (int x = 0; x < numConnections; x++) {
// 是否連接池中的數據庫連接的數量己經達到最大？最大值由類成員 maxConnections
// 指出，如果 maxConnections 爲 0 或負數，表示連接數量沒有限制。
// 如果連接數己經達到最大，即退出。
if (this.maxConnections > 0 && this.connections.size() >= this.maxConnections) {
break;
}
// 增加一個連接到連接池中（集合 connections 中）
int id = connections.size()+1;
connections.add(new PooledConnection( newConnection() ,id));
}
}
/**
* 創建一個新的數據庫連接並返回它
*
* @return 返回一個新創建的數據庫連接
*/
private Connection newConnection() throws SQLException {
// 創建一個數據庫連接
Connection conn = DriverManager.getConnection(dbUrl, dbUsername,dbPassword);
/*
// 如果這是第一次創建數據庫連接，即檢查數據庫，獲得此數據庫允許支持的
// 最大客戶連接數目
// connections.size()==0 表示目前沒有連接己被創建
if (connections.size() == 0) {
DatabaseMetaData metaData = conn.getMetaData();
int driverMaxConnections = metaData.getMaxConnections();
// 數據庫返回的 driverMaxConnections 若爲 0 ，表示此數據庫沒有最大
// 連接限制，或數據庫的最大連接限制不知道
// driverMaxConnections 爲返回的一個整數，表示此數據庫允許客戶連接的數目
// 如果連接池中設置的最大連接數量大於數據庫允許的連接數目 , 則置連接池的最大
// 連接數目爲數據庫允許的最大數目
if (driverMaxConnections > 0 && this.maxConnections > driverMaxConnections) {
this.maxConnections = driverMaxConnections;
}
}*/
return conn; // 返回創建的新的數據庫連接
}
/**
* 通過調用 getFreeConnection() 函數返回一個可用的數據庫連接 , 如果當前沒有可用的數據庫連接，並且更多的數據庫連接不能創
* 建（如連接池大小的限制），此函數等待一會再嘗試獲取。
*
* @return 返回一個可用的數據庫連接對象
* @throws SQLException
*/
public Connection getConnection() throws SQLException{
try {
wl.lock();
// 確保連接池己被創建
if (connections == null) {
return null; // 連接池還沒創建，則返回 null
}
Connection conn = getFreeConnection(); // 獲得一個可用的數據庫連接
// 如果目前沒有可以使用的連接，即所有的連接都在使用中
//下面這段for循環在實際應用中應該避免被執行，解決辦法是適當增加最大連接數
//之所以使用有限循環，是因爲客戶對延遲的忍耐是有限度的，而且已使用了訪問鎖定，該段代碼擁有對資源的獨享權。
int i=0;
while(conn == null) {
++i;
// 等一會再試
//System.out.println("Wait");
wait(200);
// 重新再試，直到獲得可用的連接，如果重試次數超過10次仍未獲得連接，返回null
conn = getFreeConnection();
if(i==10){
break;
}
// getFreeConnection() 返回的爲 null
// 則表明創建一批連接後也不可獲得可用連接
}
return conn;// 返回獲得的可用的連接
}
finally{
wl.unlock();
}
}
/**
* 本函數從連接池向量 connections 中返回一個可用的的數據庫連接，如果 當前沒有可用的數據庫連接，本函數則根據
* incrementalConnections 設置 的值創建幾個數據庫連接，並放入連接池中。 如果創建後，所有的連接仍都在使用中，則返回 null
*
* @return 返回一個可用的數據庫連接
* @throws SQLException
*/
private Connection getFreeConnection() throws SQLException {
// 從連接池中獲得一個可用的數據庫連接
Connection conn = findFreeConnection();
if (conn == null) {
// 如果目前連接池中沒有可用的連接
// 創建一些連接
createConnections(incrementalConnections);
// 重新從池中查找是否有可用連接
conn = findFreeConnection();
if (conn == null) {
// 如果創建連接後仍獲得不到可用的連接，則返回 null
return null;
}
}
return conn;
}
/**
* 查找連接池中所有的連接，查找一個可用的數據庫連接， 如果沒有可用的連接，返回 null
*
* @return 返回一個可用的數據庫連接
*/
private Connection findFreeConnection() {
Connection conn = null;
PooledConnection pConn = null;
try {
// 遍歷所有的對象，看是否有可用的連接
for(int i=0;i< connections.size();++i){
pConn = connections.get(i);
if (!pConn.isBusy()) {
// 如果此對象不忙，則獲得它的數據庫連接並把它設爲忙
conn = pConn.getConnection();
pConn.setBusy(true);
// 測試此連接是否可用
if (!testConnection(conn)) {
// 如果此連接不可再用了，則創建一個新的連接，
// 並替換此不可用的連接對象，如果創建失敗，返回 null
conn.close();//此處可能拋出異常
conn = newConnection();//此處可能拋出異常
pConn.setConnection(conn);
}
break; // 己經找到一個可用的連接，退出
}
}
} catch (SQLException e) {
if(pConn != null){
pConn.setBusy(false);//連接不能用，新建連接出異常，數據庫可能已出嚴重問題，
//setBusy保留了繼續嘗試建立連接的條件
}
e.printStackTrace();
System.out.println(" 創建數據庫連接失敗！ " + e.getMessage());
return null;
}
return conn;// 返回找到到的可用連接
}
/**
* 測試一個連接是否可用，如果不可用，關掉它並返回 false 否則可用返回 true
*
* @param conn
* 需要測試的數據庫連接
* @return 返回 true 表示此連接可用， false 表示不可用
*/
private boolean testConnection(Connection conn) {
try {
// 判斷測試表是否存在
if (testTable ==null || testTable.equals("")) {
// 如果測試表爲空，試着使用此連接的 setAutoCommit() 方法
// 來判斷連接否可用（此方法只在部分數據庫可用，如果不可用 ,
// 拋出異常）。注意：使用測試表的方法更可靠
//conn.setAutoCommit(true);
return conn.isValid(500);
} else {// 有測試表的時候使用測試表測試
// check if this connection is valid
Statement stmt = conn.createStatement();
stmt.execute("select count(*) from " + testTable);
}
} catch (SQLException e) {
// 上面拋出異常，此連接己不可用，並返回 false;
return false;
}
// 連接可用，返回 true
return true;
}
/**
* 此函數返回一個數據庫連接到連接池中，並把此連接置爲空閒。 所有使用連接池獲得的數據庫連接均應在不使用此連接時返回它。
*
* @param 需返回到連接池中的連接對象
*/
public void returnConnection(Connection conn) {
// 確保連接池存在，如果連接沒有創建（不存在），直接返回
if (connections == null) {
System.out.println(" 連接池不存在，無法返回此連接到連接池中 !");
return;
}
PooledConnection pConn = null;
try {
wl.lock();
// 遍歷連接池中的所有連接，找到這個要返回的連接對象
for(int i=0;i< connections.size();++i){
pConn = connections.get(i);
// 先找到連接池中的要返回的連接對象
if (conn == pConn.getConnection()) {
// 找到了 , 設置此連接爲空閒狀態
pConn.setBusy(false);
//System.out.println("返回："+pConn.ID());
break;
}
}
}
finally{
wl.unlock();
}
}
/**
* 關閉連接池中所有的連接，並清空連接池。
*/
public void closeConnectionPool() {//////////////////////////////////////////////////////////////////////////////////////////////
timer.cancel();
// 確保連接池存在，如果不存在，返回
if (connections == null) {
System.out.println(" 連接池不存在，無法關閉 !");
return;
}
try {
wl.lock();
PooledConnection pConn = null;
Iterator<PooledConnection> enumerate = connections.iterator();
while (enumerate.hasNext()) {
pConn = (PooledConnection) enumerate.next();
// 如果忙，等 3 秒
if (pConn.isBusy()) {
wait(3000); // 等 3 秒
}
// 3 秒後直接關閉它
closeConnection(pConn.getConnection());
System.out.println("刪除連接");
// 從連接池向量中刪除它
enumerate.remove();
}
// 置連接池爲空
connections = null;
}
finally{
wl.unlock();
}
}
/**
* 關閉一個數據庫連接
*
* @param 需要關閉的數據庫連接
*/
private void closeConnection(Connection conn) {
try {
conn.close();
} catch (SQLException e) {
System.out.println(" 關閉數據庫連接出錯： " + e.getMessage());
}
}
/**
* 使程序等待給定的毫秒數
*
* @param 給定的毫秒數
*/
private void wait(int mSeconds) {
try {
Thread.sleep(mSeconds);
} catch (InterruptedException e) {
}
}
/**
*
* 內部使用的用於保存連接池中連接對象的類 此類中有兩個成員，一個是數據庫的連接，另一個是指示此連接是否 正在使用的標誌。
*/
class PooledConnection {
private Connection connection = null;// 數據庫連接
private boolean busy = false; // 此連接是否正在使用的標誌，默認沒有正在使用
public long lastTime = 0;//最近一次使用該連接的時間
int id=0;
public int ID()
{
return id;
}
// 構造函數，根據一個 Connection 構告一個 PooledConnection 對象
public PooledConnection(Connection connection,int id) {
this.connection = connection;
lastTime = System.currentTimeMillis();
this.id = id;
}
// 返回此對象中的連接
public Connection getConnection() {
return connection;
}
// 設置此對象的，連接
public void setConnection(Connection connection) {
this.connection = connection;
}
// 獲得對象連接是否忙
public boolean isBusy() {
return busy;
}
// 設置對象的連接正在忙
public void setBusy(boolean busy) {
this.busy = busy;
lastTime = System.currentTimeMillis();
}
}
}
package mysql;
import java.math.BigDecimal;
import java.sql.*;
/**
* 以JDBC爲基礎，提供對mysql數據庫的操作
* @author IBM
*
*/
public class EasySQL {
//登錄mysql的用戶名
private static String userName = null;
//登錄mysql的密碼
private static String password = null;
//mysql裏建的數據庫名稱
private static String dbname = null;
//連接池實例
private static ConnectionPool poolInstance = null;
//從連接池中獲取的連接
private Connection conn = null;
//JDBC預編譯語句
private PreparedStatement pstmt = null;
//查詢操作返回的結果集
private ResultSet rs = null;
public static void init(String name,String key,String dbName) throws InstantiationException, IllegalAccessException, ClassNotFoundException, SQLException
{
userName = name;
password = key;
dbname = dbName;
if(poolInstance == null){
poolInstance = new ConnectionPool(userName,password ,dbname ,null);
poolInstance.createPool();
}
}
public static void close()
{
if(poolInstance != null){
poolInstance.closeConnectionPool();
poolInstance = null;
}
}
public static String status()
{
if(poolInstance != null){
return poolInstance.status();
}
else{
return "連接池尚未建立";
}
}
/**
* 獲取數據庫物理尺寸(字節)
* @return
*/
public static long size()
{
EasySQL.ReturnedData rd = EasySQL.query(
"select sum(DATA_LENGTH)+sum(INDEX_LENGTH) from information_schema.tables where table_schema='"+dbname+"'");
long size = rd.getLong(0,0);
return size;
}
//普通語句，執行一些諸如創建表之類操作
public static boolean updata(String sql)
{
if(poolInstance != null){
Connection conn = null;
try {
conn = poolInstance.getConnection();
Statement stmt = conn.createStatement();
stmt.executeUpdate(sql);
stmt.close() ;
return true;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
poolInstance.returnConnection(conn);
}
}
return false;
}
//變通語句，執行一次查詢操作
public static ReturnedData query(String sql)
{
if(poolInstance != null){
Connection conn = null;
try {
conn = poolInstance.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
ReturnedData rd = new ReturnedData(rs);
rs.close();
stmt.close() ;
return rd;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
finally{
poolInstance.returnConnection(conn);
}
}
return null;
}
/**
*
* @param statement PreparedStatement 語句
* @throws SQLException
*/
public EasySQL(String statement)
{
if(poolInstance != null){
try {
conn = poolInstance.getConnection();
pstmt = conn.prepareStatement(statement);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 設置預編譯語句參數
* @param order 參數順序，從1開始
* @param value 參數值
* @throws SQLException
*/
public void setParam(int order,String value)
{
try {
pstmt.setString(order, value);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 設置預編譯語句參數
* @param order 參數順序，從1開始
* @param value 參數值
* @throws SQLException
*/
public void setParam(int order,int value)
{
try {
pstmt.setInt(order, value);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 設置預編譯語句參數
* @param order 參數順序，從1開始
* @param value 參數值
* @throws SQLException
*/
public void setParam(int order,float value)
{
try {
pstmt.setFloat(order, value);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 設置預編譯語句參數
* @param order 參數順序，從1開始
* @param value 參數值
* @throws SQLException
*/
public void setParam(int order,double value)
{
try {
pstmt.setDouble(order, value);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 設置預編譯語句參數
* @param order 參數順序，從1開始
* @param value 參數值
* @throws SQLException
*/
public void setParam(int order,long value)
{
try {
pstmt.setBigDecimal(order, new BigDecimal(value));
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void setParam(int order,byte[] data)
{
try {
pstmt.setBytes(order, data);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 對數據庫進行寫操作，在此之前必需調用addStatement和setParam
* @param id 語句標識
* @throws SQLException
*/
public boolean write()
{
if(pstmt != null){
try {
pstmt.executeUpdate();
return true;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return false;
}
/**
* 對數據庫進行讀操作，在此之前必需調用addStatement和setStatementParam
* @param id 語句標識
* @return
* @throws SQLException
*/
public ReturnedData read()
{
if(pstmt != null){
try {
rs = pstmt.executeQuery();
ReturnedData rd = new ReturnedData(rs);
return rd;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
/**
* 在對數據庫訪問完成後釋放佔用的資源
* @throws SQLException
*/
public void release()
{
try {
if(rs != null){
rs.close();
rs = null;
}
if(pstmt != null){
pstmt.close() ;
pstmt = null;
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(poolInstance != null){
poolInstance.returnConnection(conn);
}
}
public static class ReturnedData{
public ReturnedData(ResultSet rs) throws SQLException{
ResultSetMetaData rd = rs.getMetaData();
cols = rd.getColumnCount();
rs.last();
resultCount = rs.getRow();
data = new Object[resultCount][cols];
_types = new String[cols];
for(int i=0;i<cols;++i){
int type = rd.getColumnType(i+1);
switch(type){
case java.sql.Types.INTEGER:
for(int j=0;j<resultCount;++j){
rs.absolute(j+1);
data[j][i] = rs.getInt(i+1);
}
_types[i] = "INTEGER";
break;
case java.sql.Types.FLOAT:
for(int j=0;j<resultCount;++j){
rs.absolute(j+1);
data[j][i] = rs.getFloat(i+1);
}
_types[i] = "FLOAT";
break;
case java.sql.Types.DOUBLE:
for(int j=0;j<resultCount;++j){
rs.absolute(j+1);
data[j][i] = rs.getDouble(i+1);
}
_types[i] = "DOUBLE";
break;
case java.sql.Types.BIGINT:
case java.sql.Types.DECIMAL:
for(int j=0;j<resultCount;++j){
rs.absolute(j+1);
if(rs.wasNull()){
data[j][i] = null;
}
else{
data[j][i] = rs.getBigDecimal(i+1);
}
}
_types[i] = "LONG";
break;
case java.sql.Types.VARBINARY:
for(int j=0;j<resultCount;++j){
rs.absolute(j+1);
data[j][i] = rs.getBytes(i+1);
}
_types[i] = "BYTES";
break;
case java.sql.Types.VARCHAR:
case java.sql.Types.CHAR:
case java.sql.Types.LONGVARCHAR:
for(int j=0;j<resultCount;++j){
rs.absolute(j+1);
data[j][i] = rs.getString(i+1);
}
_types[i] = "STRING";
break;
default :
_types[i] = String.valueOf(type);
break;
}
}
}
/**
* 返回的結果數量（行數）
*/
private int resultCount = 0;
public int count()
{
return resultCount;
}
String[] _types = new String[0];
/**
* 返回各列數據類型
* @return
*/
public String[] types()
{
return _types;
}
/**
* 結果中包含的成員數量（列數）
*/
private int cols = 0;
private Object data[][] = null;
/**
* 獲取String型數據
* @param row 行，從0計起
* @param col 列，從0計起
* @return
*/
public String getString(int row,int col)
{
return (String) data[row][col];
}
/**
* 獲取Int型數據
* @param row 行，從0計起
* @param col 列，從0計起
* @return
*/
public int getInt(int row,int col)
{
return (Integer) data[row][col];
}
/**
* 獲取float型數據
* @param row 行，從0計起
* @param col 列，從0計起
* @return
*/
public float getFloat(int row,int col)
{
return (Float) data[row][col];
}
/**
* 獲取double型數據
* @param row 行，從0計起
* @param col 列，從0計起
* @return
*/
public double getDouble(int row,int col)
{
return (Double) data[row][col];
}
/**
* 獲取long型數據
* @param row 行，從0計起
* @param col 列，從0計起
* @return
*/
public long getLong(int row,int col)
{
if(data[row][col] == null){
return 0;
}
else{
BigDecimal bi = (BigDecimal)data[row][col];
return bi.longValue();
}
}
public byte[] getBytes(int row,int col)
{
return (byte[]) data[row][col];
}
}
}
說明：連接池中的dbUrl = "jdbc:mysql://localhost:3306/" localhost是指本機上安裝的mysql，3306端口是指所安裝mysql的通信端口。
windows下操作mysql：
首先確保mysql服務已啓動（一般安裝好mysql後就會添加到系統服務列表裏）。操作mysql可以使用cmd命令提示符。
登錄: mysql -u root -p （隨後需要輸入密碼）
創建數據庫：create ***
選擇要操作的數據庫 use ***
一些命令：
mysql -u root -p
CREATE DATABASE kyd;
CREATE USER 'client'@'%' IDENTIFIED BY '1011';
GRANT ALL ON kyd.* TO 'client'@'%';
use test;
show tables;
DROP TABLE xxx;
truncate table Data2; 而truncate相當於保留mysql表的結構，重新創建了這個表，所有的狀態都相當於新表。
ALTER TABLE data2 ADD INDEX user (user);
CREATE TABLE Data_n(
ctime BIGINT not NULL,
atime BIGINT default 0,
folder INTEGER default 0,
filesID INTEGER default 0,
user INTEGER default 0,
flag INTEGER default 0,
creator INTEGER default 0,
title VARBINARY(255),
files VARBINARY(2046),
texts VARCHAR(255),
users VARCHAR(1470),
PRIMARY KEY (ctime)) DEFAULT CHARSET=ASCII;
CREATE TABLE Text1(
id INTEGER not NULL,
txt VARCHAR(512),
PRIMARY KEY ( id )) DEFAULT CHARSET=utf8;
CREATE TABLE Text2(
id INTEGER not NULL,
txt VARCHAR(4096),
PRIMARY KEY ( id )) DEFAULT CHARSET=utf8;
CREATE TABLE Text3(
id INTEGER not NULL,
txt VARCHAR(16384),
PRIMARY KEY ( id )) DEFAULT CHARSET=utf8;
CREATE TABLE Text4(
id INTEGER not NULL,
txt MEDIUMTEXT,
PRIMARY KEY ( id )) DEFAULT CHARSET=utf8;
CREATE TABLE Text_df(
ctime BIGINT not NULL,
title VARCHAR(128),
body TEXT,
PRIMARY KEY ( ctime )) DEFAULT CHARSET=utf8;
CREATE TABLE Text_df (
ctime BIGINT NOT NULL PRIMARY KEY,
title VARCHAR(128),
body TEXT,
FULLTEXT (title,body) WITH PARSER ngram
) ENGINE=InnoDB CHARACTER SET utf8;
//查看指定數據庫的表的大小
select concat(round(sum(DATA_LENGTH/1024/1024),2),'MB') as data from TABLES where table_schema='test' and table_name='data';
select * from data order by ctime desc limit 0,1;
linux下操作mysql
使用命令 # service mysqld status 或者 # service mysql status 命令來查看mysql 的啓動狀態
如果是 mysqld is stopped 那就說明mysql服務是停止狀態，
如果是 mysqld is running 那就說明mysql服務是啓動狀態
詳細可查閱本博客linux類別下文章
linux下操作mysql使用putty連接服務器後就和windows下命令提示符模式差不多了。
EasySQL類的使用
(1)初始化和關閉
在 ContextListener 監聽類中
EasySQL.init(Config.attr("mysql", "name"), Config.attr("mysql", "key"), Config.attr("mysql", "db"));
EasySQL.close();
（2）執行SQL語句
讀操作：
EasySQL es = new EasySQL("select * from "+sheet+" where ctime="+ctime);
EasySQL.ReturnedData rd = es.read();
for(int i=0;i<rd.count();++i){
long _ctime = rd.getLong(i, 0);
long atime = rd.getLong(i, 1);
long l1 = rd.getLong(i, 2);
long l2 = rd.getLong(i, 3);
int folder = rd.getInt(i, 4);
int filesID = rd.getInt(i, 5);
int user = rd.getInt(i, 6);
int flag = rd.getInt(i, 7);
int creator = rd.getInt(i, 8);
byte[] b1 = rd.getBytes(i, 9);
byte[] b2 = rd.getBytes(i, 10);
String title = "";
String files = "";
try {
if(b1 != null && b1.length > 0)
{title = new String(b1,"utf-8");}
if(b2 != null && b2.length > 0)
{files = new String(b2,"utf-8");}
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String texts = rd.getString(i, 11);
String users = rd.getString(i, 12);
}
es.release();
寫操作
EasySQL es = new EasySQL("insert into "+sheet+" (ctime,atime,folder,l2) values (?,?,?,?)");
es.setParam(1,ctime);
es.setParam(2,ctime);
es.setParam(3,folder);
es.setParam(4,order);
es.write();
es.release();
String sql = "UPDATE "+sheet+" SET files = ? ,atime = ? WHERE ctime = "+ctime;
EasySQL es = new EasySQL(sql);
try {
byte[] b = value.getBytes("utf-8");
es.setParam(1,b);
es.setParam(2,System.currentTimeMillis());
es.write();
es.release();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String sql = "UPDATE "+sheet+" SET texts = ? WHERE ctime = "+ctime;
EasySQL es = new EasySQL(sql);
es.setParam(1,value);
es.write();
es.release();
String sql = "UPDATE "+sheet+" SET title = ? WHERE ctime = "+ctime;
EasySQL es = new EasySQL(sql);
try {
byte[] b = value.getBytes("utf-8");
es.setParam(1,b);
es.write();
es.release();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String sql = "UPDATE "+sheet+" SET files = ? ,texts = ? ,atime = ? WHERE ctime = "+ctime;
EasySQL es = new EasySQL(sql);
try {
byte[] b = value.getBytes("utf-8");
es.setParam(1,b);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
es.setParam(2,value2);
es.setParam(3,System.currentTimeMillis());
es.write();
es.release();
EasySQL.updata("delete from "+sheet+" where ctime="+ctime);
String sql = "UPDATE "+sheet+" SET folder=? , files = ? ,texts = ? , filesID=?,creator=?, user=?, flag=?, atime = ?,title=?,users=? WHERE ctime = "+sm.ctime;
EasySQL es = new EasySQL(sql);
es.setParam(1,sm.folder);
es.setParam(3,sm.texts);
es.setParam(4,sm.filesID);
es.setParam(5,sm.creator);
es.setParam(6,sm.user);
es.setParam(7,sm.flag);
es.setParam(8,System.currentTimeMillis());
es.setParam(10,sm.users);
try {
byte[] b1 = sm.files.getBytes("utf-8");
byte[] b2 = sm.title.getBytes("utf-8");
es.setParam(2,b1);
es.setParam(9,b2);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
es.write();
es.release();
}