数据库的连接

/**
 * SQL 基本操作 通过它,可以很轻松的使用 JDBC 来操纵数据库
 * 
 * @author Null
 */
public class DBHelper {


/**
* 驱动
*/
// public static String driver =
// "com.microsoft.jdbc.sqlserver.SQLServerDriver";
public static String driver = "com.mysql.jdbc.Driver";
/**
* 连接字符串
*/
// public static String url =
// "jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=st";
public static String url = "jdbc:mysql://localhost:3306/ddd";//相应的·数据库名
/**
* 用户名
*/
public static String user = "root";
/**
* 密码
*/
public static String password = "root";


/**
* 不允许实例化该类
*/
private DBHelper() {
}


/**
* 获取一个数据库连接 通过设置类的 driver / url / user / password 这四个静态变量来 设置数据库连接属性
* 
* @return 数据库连接
*/
public static Connection getConnection() {
try {
// 获取驱动
Class.forName(driver);
} catch (ClassNotFoundException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
}


try {
return DriverManager.getConnection(url, user, password);
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
return null;
}
}


/**
* 获取一个 Statement 该 Statement 已经设置数据集 可以滚动,可以更新
* 
* @return 如果获取失败将返回 null,调用时记得检查返回值
*/
public static Statement getStatement() {
Connection conn = getConnection();
if (conn == null) {
return null;
}
try {
return conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);

} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
close(conn);
}
return null;
}


/**
* 获取一个 Statement 该 Statement 已经设置数据集 可以滚动,可以更新
* 
* @param conn
*            数据库连接
* @return 如果获取失败将返回 null,调用时记得检查返回值
*/
public static Statement getStatement(Connection conn) {
if (conn == null) {
return null;
}
try {


return conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
// 设置数据集可以滚动,可以更新
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
return null;
}
}


/**
* 获取一个带参数的 PreparedStatement 该 PreparedStatement 已经设置数据集 可以滚动,可以更新
* 
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return 如果获取失败将返回 null,调用时记得检查返回值
*/
public static PreparedStatement getPreparedStatement(String cmdText,
Object[] cmdParams) {
Connection conn = getConnection();
if (conn == null) {
return null;
}


PreparedStatement pstmt = null;
try {


pstmt = conn
.prepareStatement(cmdText, ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
int i = 1;
for (Object item : cmdParams) // java
// foreach遍历集合,要求集合类实现Enumeration接口
{
pstmt.setObject(i, item);
i++;
}
} catch (SQLException e) {
e.printStackTrace();
close(conn);
}
return pstmt;
}


/**
* 获取一个带参数的 PreparedStatement 该 PreparedStatement 已经设置数据集 可以滚动,可以更新
* 
* @param conn
*            数据库连接
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return 如果获取失败将返回 null,调用时记得检查返回值
*/
public static PreparedStatement getPreparedStatement(Connection conn,
String cmdText, Object[] cmdParams) {
if (conn == null) {
return null;
}


PreparedStatement pstmt = null;
try {
pstmt = conn
.prepareStatement(cmdText, ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
int i = 1;
for (Object item : cmdParams) {
pstmt.setObject(i, item);
i++;
}
} catch (SQLException ex) {
System.out.println(ex.getMessage());
// ex.printStackTrace();
close(pstmt);
}
return pstmt;
}


/**
* 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
* 
* @param cmdText
*            SQL 语句
* @return 非负数:正常执行; -1:执行错误; -2:连接错误
*/
public static int ExecSql(String cmdText) {
Statement stmt = getStatement();
if (stmt == null) {
return -2;
}
int i;
try {
i = stmt.executeUpdate(cmdText);
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null,ex);
System.out.println(ex.getMessage());
i = -1;
}
closeConnection(stmt);
return i;
}


/**
* 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
* 
* @param cmdText
*            SQL 语句
* @return 非负数:正常执行; -1:执行错误; -2:连接错误
*/
public static int ExecSql(Connection conn, String cmdText) {
Statement stmt = getStatement(conn);
if (stmt == null) {
return -2;
}
int i;
try {
i = stmt.executeUpdate(cmdText);


} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());


i = -1;
}
close(stmt);
return i;
}


/**
* 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
* 
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return 非负数:正常执行; -1:执行错误; -2:连接错误
*/
public static int ExecSql(String cmdText, Object[] cmdParams) {
PreparedStatement pstmt = getPreparedStatement(cmdText, cmdParams);
if (pstmt == null) {
return -2;
}
int i;
try {
i = pstmt.executeUpdate();
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
i = -1;
}
closeConnection(pstmt);
return i;
}


/**
* 执行 SQL 语句,返回结果为整型 主要用于执行非查询语句
* 
* @param conn
*            数据库连接
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return 非负数:正常执行; -1:执行错误; -2:连接错误
*/
public static int ExecSql(Connection conn, String cmdText,
Object[] cmdParams) {
PreparedStatement pstmt = getPreparedStatement(conn, cmdText, cmdParams);
if (pstmt == null) {
return -2;
}
int i;
try {
i = pstmt.executeUpdate();


} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
i = -1;
}
close(pstmt);
return i;
}


/**
* 返回结果集的第一行的一列的值,其他忽略
* 
* @param cmdText
*            SQL 语句
* @return
*/
public static Object ExecScalar(String cmdText) {
ResultSet rs = getResultSet(cmdText);
Object obj = getScalar(rs);
closeConnection(rs);
return obj;
}


/**
* 返回结果集的第一行的一列的值,其他忽略
* 
* @param conn
*            数据库连接
* @param cmdText
*            SQL 语句
* @return
*/
public static Object ExecScalar(Connection conn, String cmdText) {
ResultSet rs = getResultSet(conn, cmdText);
Object obj = getScalar(rs);
closeEx(rs);
return obj;
}


/**
* 返回结果集的第一行的一列的值,其他忽略
* 
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return
*/
public static Object ExecScalar(String cmdText, Object[] cmdParams) {
ResultSet rs = getResultSet(cmdText, cmdParams);
Object obj = getScalar(rs);
closeConnection(rs);
return obj;
}


/**
* 返回结果集的第一行的一列的值,其他忽略
* 
* @param conn
*            数据库连接
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return
*/
public static Object ExecScalar(Connection conn, String cmdText,
Object[] cmdParams) {
ResultSet rs = getResultSet(conn, cmdText, cmdParams);
Object obj = getScalar(rs);
closeEx(rs);
return obj;
}


/**
* 返回一个 ResultSet
* 
* @param cmdText
*            SQL 语句
* @return
*/
public static ResultSet getResultSet(String cmdText) {
Statement stmt = getStatement();
if (stmt == null) {
return null;
}
try {
return stmt.executeQuery(cmdText);
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
closeConnection(stmt);
}
return null;
}


/**
* 返回一个 ResultSet
* 
* @param conn
* @param cmdText
*            SQL 语句
* @return
*/
public static ResultSet getResultSet(Connection conn, String cmdText) {
Statement stmt = getStatement(conn);
if (stmt == null) {
return null;
}
try {
return stmt.executeQuery(cmdText);
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
close(stmt);
}
return null;
}


/**
* 返回一个 ResultSet
* 
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return
*/
public static ResultSet getResultSet(String cmdText, Object[] cmdParams) {
PreparedStatement pstmt = getPreparedStatement(cmdText, cmdParams);
if (pstmt == null) {
return null;
}
try {
return pstmt.executeQuery();
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
closeConnection(pstmt);
}
return null;
}


/**
* 返回一个 ResultSet
* 
* @param conn
*            数据库连接
* @param cmdText
*            需要 ? 参数的 SQL 语句
* @param cmdParams
*            SQL 语句的参数表
* @return
*/
public static ResultSet getResultSet(Connection conn, String cmdText,
Object[] cmdParams) {
PreparedStatement pstmt = getPreparedStatement(conn, cmdText, cmdParams);
if (pstmt == null) {
return null;
}
try {
return pstmt.executeQuery();
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
close(pstmt);
}
return null;
}


public static Object getScalar(ResultSet rs) {
if (rs == null) {
return null;
}
Object obj = null;
try {
if (rs.next()) {
obj = rs.getObject(1);
}
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
}
return obj;
}


private static void close(Object obj) {
if (obj == null) {
return;
}
try {
if (obj instanceof Statement) {
((Statement) obj).close();
} else if (obj instanceof PreparedStatement) {
((PreparedStatement) obj).close();
} else if (obj instanceof ResultSet) {
((ResultSet) obj).close();
} else if (obj instanceof Connection) {
((Connection) obj).close();
}
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
}
}


private static void closeEx(Object obj) {
if (obj == null) {
return;
}


try {
if (obj instanceof Statement) {
((Statement) obj).close();
} else if (obj instanceof PreparedStatement) {
((PreparedStatement) obj).close();
} else if (obj instanceof ResultSet) {
((ResultSet) obj).getStatement().close();
} else if (obj instanceof Connection) {
((Connection) obj).close();
}
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
}


}


private static void closeConnection(Object obj) {
if (obj == null) {
return;
}
try {
if (obj instanceof Statement) {
((Statement) obj).getConnection().close();
} else if (obj instanceof PreparedStatement) {
((PreparedStatement) obj).getConnection().close();
} else if (obj instanceof ResultSet) {
((ResultSet) obj).getStatement().getConnection().close();
} else if (obj instanceof Connection) {
((Connection) obj).close();
}
} catch (SQLException ex) {
// Logger.getLogger(DBHelper.class.getName()).log(Level.SEVERE,
// null, ex);
System.out.println(ex.getMessage());
}
}
}