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();
}
866
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
