在使用PreparedStatement防止SQL注入時，順帶輸出完整的SQL語句

阿新 • • 發佈：2018-11-26

本文轉載於：https://www.cnblogs.com/aipan/p/7237854.html 但有修改和補充

原因：

PreparedStatement介面沒有提供什麼方法可以直接輸出封裝好的sql語句，所以在這找了一個比較實用的類，自己寫，一次寫成，終身受益。具體程式碼如下。

程式碼：

特別注意一下前面幾個方法，最好是實現PreparedStatement介面，將裡面的所有方法直接複製過去，然後有少了的方法就自動新增就行。

import java.io.InputStream;    
import java.io.Reader;    
import java.math.BigDecimal;    
import java.net.URL;    
import java.sql.Array;    
import java.sql.Blob;    
import java.sql.Clob;    
import java.sql.Connection;    
import java.sql.Date;    
import java.sql.NClob;  
import java.sql.ParameterMetaData;    
import java.sql.PreparedStatement;    
import java.sql.Ref;    
import java.sql.ResultSet;    
import java.sql.ResultSetMetaData;    
import java.sql.RowId;  
import java.sql.SQLException;    
import java.sql.SQLWarning;    
import java.sql.SQLXML;  
import java.sql.Time;    
import java.sql.Timestamp;    
import java.util.ArrayList;    
import java.util.Calendar;    
    
/**  
 *   
 * 專案名稱：CFR      
 * 類名稱：LoggableStatement      
 * 類描述：擴充套件PreparedStatement,以便輸出執行的sql語句,即sql日誌    
 * 建立時間：2010-6-22 下午10:47:39         
 * @version   1.0  
 * @author zhh  
*來自網路 *  
 */    
public class LoggableStatement implements PreparedStatement {    
    
    /** used for storing parameter values needed for producing log */    
    private ArrayList parameterValues;    
    
    /** the query string with question marks as parameter placeholders */    
    private String sqlTemplate;    
    
    /** a statement created from a real database connection */    
    private PreparedStatement wrappedStatement;    
    
    public LoggableStatement(Connection connection, String sql)    
            throws SQLException {    
        // use connection to make a prepared statement    
        wrappedStatement = connection.prepareStatement(sql);    
        sqlTemplate = sql;    
        parameterValues = new ArrayList();    
    }    
    
    private void saveQueryParamValue(int position, Object obj) {    
        String strValue;    
        if (obj instanceof String || obj instanceof Date) {    
            // if we have a String, include '' in the saved value    
            strValue = "'" + obj + "'";    
        } else {    
            if (obj == null) {    
                // convert null to the string null    
                strValue = "null";    
            } else {    
                // unknown object (includes all Numbers), just call toString    
                strValue = obj.toString();    
            }    
        }    
        // if we are setting a position larger than current size of    
        // parameterValues, first make it larger    
        while (position >= parameterValues.size()) {    
    
            parameterValues.add(null);    
        }    
        // save the parameter    
        parameterValues.set(position, strValue);    
    }    
    
    // 這一步是對ArrayList與sql進行處理，輸出完整的sql語句    
    public String getQueryString() {    
        int len = sqlTemplate.length();    
        StringBuffer t = new StringBuffer(len * 2);    
    
        if (parameterValues != null) {    
            int i = 1, limit = 0, base = 0;    
    
            while ((limit = sqlTemplate.indexOf('?', limit)) != -1) {    
                t.append(sqlTemplate.substring(base, limit));    
                t.append(parameterValues.get(i));    
                i++;    
                limit++;    
                base = limit;    
            }    
            if (base < len) {    
                t.append(sqlTemplate.substring(base));    
            }    
        }    
        return t.toString();    
    }    
    
    public void addBatch() throws SQLException {    
        wrappedStatement.addBatch();    
    }    
    
    public void clearParameters() throws SQLException {    
        wrappedStatement.clearParameters();    
    }    
    
    public boolean execute() throws SQLException {    
        return wrappedStatement.execute();    
    }    
    
    public ResultSet executeQuery() throws SQLException {    
        return wrappedStatement.executeQuery();    
    }    
    
    public int executeUpdate() throws SQLException {    
        return wrappedStatement.executeUpdate();    
    }    
    
    public ResultSetMetaData getMetaData() throws SQLException {    
        return wrappedStatement.getMetaData();    
    }    
    
    public ParameterMetaData getParameterMetaData() throws SQLException {    
        return wrappedStatement.getParameterMetaData();    
    }    
    
    public void setArray(int i, Array x) throws SQLException {    
        wrappedStatement.setArray(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setAsciiStream(int parameterIndex, InputStream x, int length)    
            throws SQLException {    
        wrappedStatement.setAsciiStream(parameterIndex, x, length);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setBigDecimal(int parameterIndex, BigDecimal x)    
            throws SQLException {    
        wrappedStatement.setBigDecimal(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setBinaryStream(int parameterIndex, InputStream x, int length)    
            throws SQLException {    
        wrappedStatement.setBinaryStream(parameterIndex, x, length);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setBlob(int i, Blob x) throws SQLException {    
        wrappedStatement.setBlob(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setBoolean(int parameterIndex, boolean x) throws SQLException {    
        wrappedStatement.setBoolean(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Boolean(x));    
    }    
    
    public void setByte(int parameterIndex, byte x) throws SQLException {    
        wrappedStatement.setByte(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Byte(x));    
    }    
    
    public void setBytes(int parameterIndex, byte[] x) throws SQLException {    
        wrappedStatement.setBytes(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setCharacterStream(int parameterIndex, Reader reader, int length)    
            throws SQLException {    
        wrappedStatement.setCharacterStream(parameterIndex, reader, length);    
        saveQueryParamValue(parameterIndex, reader);    
    }    
    
    public void setClob(int i, Clob x) throws SQLException {    
        wrappedStatement.setClob(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setDate(int parameterIndex, Date x) throws SQLException {    
        wrappedStatement.setDate(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setDate(int parameterIndex, Date x, Calendar cal)    
            throws SQLException {    
        wrappedStatement.setDate(parameterIndex, x, cal);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setDouble(int parameterIndex, double x) throws SQLException {    
        wrappedStatement.setDouble(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Double(x));    
    }    
    
    public void setFloat(int parameterIndex, float x) throws SQLException {    
        wrappedStatement.setFloat(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Float(x));    
    }    
    
    public void setInt(int parameterIndex, int x) throws SQLException {    
        wrappedStatement.setInt(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Integer(x));    
    }    
    
    public void setLong(int parameterIndex, long x) throws SQLException {    
        wrappedStatement.setLong(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Long(x));    
    }    
    
    public void setNull(int parameterIndex, int sqlType) throws SQLException {    
        wrappedStatement.setNull(parameterIndex, sqlType);    
        saveQueryParamValue(parameterIndex, new Integer(sqlType));    
    }    
    
    public void setNull(int paramIndex, int sqlType, String typeName)    
            throws SQLException {    
        wrappedStatement.setNull(paramIndex, sqlType, typeName);    
        saveQueryParamValue(paramIndex, new Integer(sqlType));    
    }    
    
    public void setObject(int parameterIndex, Object x) throws SQLException {    
        wrappedStatement.setObject(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setObject(int parameterIndex, Object x, int targetSqlType)    
            throws SQLException {    
        wrappedStatement.setObject(parameterIndex, x, targetSqlType);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setObject(int parameterIndex, Object x, int targetSqlType,    
            int scale) throws SQLException {    
        wrappedStatement.setObject(parameterIndex, x, targetSqlType, scale);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setRef(int i, Ref x) throws SQLException {    
        wrappedStatement.setRef(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setShort(int parameterIndex, short x) throws SQLException {    
        wrappedStatement.setShort(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Short(x));    
    }    
    
    public void setString(int parameterIndex, String x) throws SQLException {    
        wrappedStatement.setString(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTime(int parameterIndex, Time x) throws SQLException {    
        wrappedStatement.setTime(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTime(int parameterIndex, Time x, Calendar cal)    
            throws SQLException {    
        wrappedStatement.setTime(parameterIndex, x, cal);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTimestamp(int parameterIndex, Timestamp x)    
            throws SQLException {    
        wrappedStatement.setTimestamp(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)    
            throws SQLException {    
        wrappedStatement.setTimestamp(parameterIndex, x, cal);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setURL(int parameterIndex, URL x) throws SQLException {    
        wrappedStatement.setURL(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setUnicodeStream(int parameterIndex, InputStream x, int length)    
            throws SQLException {    
        wrappedStatement.setUnicodeStream(parameterIndex, x, length);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void addBatch(String sql) throws SQLException {    
        wrappedStatement.addBatch(sql);    
    }    
    
    public void cancel() throws SQLException {    
        wrappedStatement.cancel();    
    }    
    
    public void clearBatch() throws SQLException {    
        wrappedStatement.clearBatch();    
    }    
    
    public void clearWarnings() throws SQLException {    
        wrappedStatement.clearWarnings();    
    }    
    
    public void close() throws SQLException {    
        wrappedStatement.close();    
    }    
    
    public boolean execute(String sql) throws SQLException {    
        return wrappedStatement.execute(sql);    
    }    
    
    public boolean execute(String sql, int autoGeneratedKeys)    
            throws SQLException {    
        return wrappedStatement.execute(sql, autoGeneratedKeys);    
    }    
    
    public boolean execute(String sql, int[] columnIndexes) throws SQLException {    
        return wrappedStatement.execute(sql, columnIndexes);    
    }    
    
    public boolean execute(String sql, String[] columnNames)    
            throws SQLException {    
        return wrappedStatement.execute(sql, columnNames);    
    }    
    
    public int[] executeBatch() throws SQLException {    
        return wrappedStatement.executeBatch();    
    }    
    
    public ResultSet executeQuery(String sql) throws SQLException {    
        return wrappedStatement.executeQuery(sql);    
    }    
    
    public int executeUpdate(String sql) throws SQLException {    
        return wrappedStatement.executeUpdate(sql);    
    }    
    
    public int executeUpdate(String sql, int autoGeneratedKeys)    
            throws SQLException {    
        return wrappedStatement.executeUpdate(sql, autoGeneratedKeys);    
    }    
    
    public int executeUpdate(String sql, int[] columnIndexes)    
            throws SQLException {    
        return wrappedStatement.executeUpdate(sql, columnIndexes);    
    }    
    
    public int executeUpdate(String sql, String[] columnNames)    
            throws SQLException {    
        return wrappedStatement.executeUpdate(sql, columnNames);    
    }    
    
    public Connection getConnection() throws SQLException {    
        return wrappedStatement.getConnection();    
    }    
    
    public int getFetchDirection() throws SQLException {    
        return wrappedStatement.getFetchDirection();    
    }    
    
    public int getFetchSize() throws SQLException {    
        return wrappedStatement.getFetchSize();    
    }    
    
    public ResultSet getGeneratedKeys() throws SQLException {    
        return wrappedStatement.getGeneratedKeys();    
    }    
    
    public int getMaxFieldSize() throws SQLException {    
        return wrappedStatement.getMaxFieldSize();    
    }    
    
    public int getMaxRows() throws SQLException {    
        return wrappedStatement.getMaxRows();    
    }    
    
    public boolean getMoreResults() throws SQLException {    
        return wrappedStatement.getMoreResults();    
    }    
    
    public boolean getMoreResults(int current) throws SQLException {    
        return wrappedStatement.getMoreResults(current);    
    }    
    
    public int getQueryTimeout() throws SQLException {    
        return wrappedStatement.getQueryTimeout();    
    }    
    
    public ResultSet getResultSet() throws SQLException {    
        return wrappedStatement.getResultSet();    
    }    
    
    public int getResultSetConcurrency() throws SQLException {    
        return wrappedStatement.getResultSetConcurrency();    
    }    
    
    public int getResultSetHoldability() throws SQLException {    
        return wrappedStatement.getResultSetHoldability();    
    }    
    
    public int getResultSetType() throws SQLException {    
        return wrappedStatement.getResultSetType();    
    }    
    
    public int getUpdateCount() throws SQLException {    
        return wrappedStatement.getUpdateCount();    
    }    
    
    public SQLWarning getWarnings() throws SQLException {    
        return wrappedStatement.getWarnings();    
    }    
    
    public void setCursorName(String name) throws SQLException {    
        wrappedStatement.setCursorName(name);    
    }    
    
    public void setEscapeProcessing(boolean enable) throws SQLException {    
        wrappedStatement.setEscapeProcessing(enable);    
    }    
    
    public void setFetchDirection(int direction) throws SQLException {    
        wrappedStatement.setFetchDirection(direction);    
    }    
    
    public void setFetchSize(int rows) throws SQLException {    
        wrappedStatement.setFetchSize(rows);    
    }    
    
    public void setMaxFieldSize(int max) throws SQLException {    
        wrappedStatement.setMaxFieldSize(max);    
    }    
    
    public void setMaxRows(int max) throws SQLException {    
        wrappedStatement.setMaxFieldSize(max);    
    }    
    
    public void setQueryTimeout(int seconds) throws SQLException {    
        wrappedStatement.setQueryTimeout(seconds);    
    }  
  
    public void setAsciiStream(int parameterIndex, InputStream x)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setAsciiStream(int parameterIndex, InputStream x, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBinaryStream(int parameterIndex, InputStream x)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBinaryStream(int parameterIndex, InputStream x, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBlob(int parameterIndex, InputStream inputStream)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBlob(int parameterIndex, InputStream inputStream, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setCharacterStream(int parameterIndex, Reader reader)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setCharacterStream(int parameterIndex, Reader reader,  
            long length) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setClob(int parameterIndex, Reader reader) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setClob(int parameterIndex, Reader reader, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNCharacterStream(int parameterIndex, Reader value)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNCharacterStream(int parameterIndex, Reader value,  
            long length) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNClob(int parameterIndex, NClob value) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNClob(int parameterIndex, Reader reader) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNClob(int parameterIndex, Reader reader, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNString(int parameterIndex, String value)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setRowId(int parameterIndex, RowId x) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setSQLXML(int parameterIndex, SQLXML xmlObject)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public boolean isClosed() throws SQLException {  
        // TODO Auto-generated method stub  
        return false;  
    }  
  
    public boolean isPoolable() throws SQLException {  
        // TODO Auto-generated method stub  
        return false;  
    }  
  
    public void setPoolable(boolean poolable) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public boolean isWrapperFor(Class<?> iface) throws SQLException {  
        // TODO Auto-generated method stub  
        return false;  
    }  
  
    public <T> T unwrap(Class<T> iface) throws SQLException {  
        // TODO Auto-generated method stub  
        return null;  
    }    
}

呼叫並輸出：

下面程式碼呼叫的重點就是將

ps = conn.prepareStatement(sql);

替換成

ps = new LoggableStatement(conn,sql);

然後加入sql中佔位符所需要的資料後輸出控制檯，檢視SQL程式碼，程式碼執行效果和之前一樣，只是能輸出SQL程式碼而已

輸出：

System.out.println("Executing SQL:　"+((LoggableStatement)ps).getQueryString());

Connection conn = null;  
PreparedStatement ps = null;  
ResultSet rs = null;  
JdbcProp jp = new JdbcProp();  
try{
    // 這裡是從他人弄過來的，只是sql語句，沒有改。
    String sql = " insert into someInfection_list (INFECTION_ID, INFECTION_CARDID, INFECTION_HOSADDRCODE, INFECTION_CARDSN, "  
    +" INFECTION_NAME, INFECTION_PARENTNAME, INFECTION_SEX, INFECTION_PHONE, INFECTION_IDSN, INFECTION_ORG,"  
    +" INFECTION_ADDR, INFECTION_ADDRCODE, INFECTION_ADDRTYPE, INFECTION_PERSONTYPE, INFECTION_TAKENDATE,"  
    +" INFECTION_DIAGNOSEDATE, INFECTION_DEADDATE, INFECTION_TYPE, INFECTION_DOCTOR, INFECTION_INFECTIONTYPE,"  
    +" infection_infectionsn, infection_zhongshendate, INFECTION_USERID, INFECTION_MEMO, INFECTION_BIRTHDAY,"  
    +" INFECTION_DOCTORFILLDATE , infection_oldcardid, INFECTION_CARDCREATEDDATE, infection_xianshen,"  
    +" infection_shishen, infection_shengshen, INFECTION_DELETEDATE, INFECTION_REPORTORG, INFECTION_ORGTYPE,"  
    +" INFECTION_REPAIRDATE, infection_flag, infection_datasource, infection_firstinfection) " 
    +" values "
    +"(sys_guid(),?,?,?,?,?,?,?,?,?, " //  10  
    +"?,?,?,?,to_date(?,'yyyy-mm-dd hh24:mi:ss'),to_date(?,'yyyy-mm-dd hh24:mi:ss'),to_date(?,'yyyy-mm-dd hh24:mi:ss'),?,?,?, "
    +"?, to_date(?,'yyyy-mm-dd hh24:mi:ss'),?,?,to_date(?,'yyyy-mm-dd hh24:mi:ss')," //25  
    +"to_date(?,'yyyy-mm-dd hh24:mi:ss'),?,to_date(?,'yyyy-mm-dd hh24:mi:ss'),to_date(?,'yyyy-mm-dd hh24:mi:ss'),to_date(?,'yyyy-mm-dd hh24:mi:ss'), " 
    +"?,to_date(?,'yyyy-mm-dd hh24:mi:ss'),?,?,to_date(?,'yyyy-mm-dd hh24:mi:ss'),?,?,?)";  
    conn = jp.getConn();  
//  ps = conn.prepareStatement(sql);  
    ps = new LoggableStatement(conn,sql); // 1.主要區別就是上面那句替換成這個   
    ps.setString(1, paras[0]);  // 一般這裡我喜歡用for迴圈來將值放置到PrepareStatement
    ...
            ... 
    System.out.println("Executing SQL:　"+((LoggableStatement)ps).getQueryString()); // 2. 然後就是在這輸出，其他的你該怎麼寫就怎麼寫
              
    ps.executeUpdate();
} catch (SQLException e) {
    e.printStackTrace();
}

下面新增我自己的程式碼和效果圖：

      /**
        * 查詢結果集
        * 
        * @param sql 		sql語句
        * @param params 	引數陣列
        * @return               查詢結果集
        * @throws SQLException 
        */
	public ResultSet executeQuery(String sql, Object... params) throws SQLException {
		PreparedStatement pstmt = null;
        ResultSet rs = null;
            try {
             // pstmt = conn.prepareStatement(sql);
                pstmt = new LoggableStatement (conn, sql); // conn 就是 Connection
                System.out.println(params.length);
                System.out.println(params[1]);
                for (int i = 0; i < params.length; i++) {
            	    System.out.println(i);
                    pstmt.setObject(i + 1, params[i]);
                }
                System.out.println("Executing SQL: " + ((LoggableStatement )pstmt).getQueryString());
                rs = pstmt.executeQuery();
            } catch (SQLException e) {
                e.printStackTrace();
                throw e;
            }
        return rs;
	}

在使用PreparedStatement防止SQL注入時，順帶輸出完整的SQL語句

本文轉載於：https://www.cnblogs.com/aipan/p/7237854.html 但有修改和補充原因： PreparedStatement介面沒有提供什麼方法可以直接輸出封裝好的sql語句，所以在這找了一個比較實用的類，自己寫，一次寫成，終身受益。具體程式碼如下。

spring 依賴注入時，什麼時候會建立代理類

問題來源　以前一直有個疑惑，為什麼我建立的controller中注入的service類有時候是代理類，有時候是普通javabean，當時能力不夠，現在已經有了點經驗就大膽跟了跟原始碼，看看到底咋回事。　　首先看看問題現象：　　a1:service是代理類

Jfinal中使用日誌框架輸出完整sql語句信息(mysql+oracle)

mysql 數據庫項目信息 sql語句 Jfinal中使用日誌框架輸出完整sql語句信息(mysql+oracle)1、引入Jar包。//必須引入的jar包log4j-1.2.17.jarlog4jdbc4-1.2.jarslf4j-api-1.7.5.jar//二選一的jar包，如果

mysql儲存過程迴圈遍歷sql結果集，並執行動態sql

/* 將其他幾張表資料複製到一張總表中 */ DROP PROCEDURE IF EXISTS sp_customer; CREATE PROCEDURE sp_customer() BEGIN -- 需要執行的SQL語句 DECLARE v_sql_1 VARCH

某公司的SQL 面試題目，考考你的SQL熟練程度

某公司的SQL 面試題目 1-10題目答案都是一句話 1、請寫出SQL語句計算今天距離2005元旦的分鐘數。答案：（SQL入門題目，不會做的話，把書從頭再看十遍吧） 2、請一句SQL寫出：如果person(personname,deptname) 表中沒有 “財務部”的“

[hibernate]log4jdbc日誌輸出完整SQL語句

att 完整 sql 連接 end 需要 result mysq num 1.在maven引入: <dependency> <groupId>log4j</group

今天做的一個SQL面試題，用到了HAVING語句來限制函式關係

面試題目如上。第一題的問題主要是理解問題，容易寫成去掉"李明"的課程的學生，而不是沒選他課的學生比如錯誤sql：SELECTS.SNOFROMSLEFT JOIN SC ON S.SNO = SC.SNOWHERESC.CNO NOT IN (SELECTCNOFROMCWH

c＃配置問題以及簡單防止sql註入，連接池問題，sqldatareader對象對於connection對象的釋放

c#添加引用。system configurationconfigurationManager.AppSettings[“”]<appSetings><add key=“” value=“”></appSetings><connectionStrings><

SQL Server 存儲過程種遊標的使用，print輸出問題

使用 ext 姓名 sta .... -- close creat rop ......此處略去N個字...... DROP PROCEDURE test_proc; CREATE PROCEDURE test_proc AS DECLARE @u_id INT ;

log4j不列印sql，不輸出日誌檔案到指定目錄

#log4j.rootLogger=CONSOLE,info,error,DEBUG log4j.rootLogger=infoA,errorA,CONSOLE,DEBUGA //注意這裡不要用INFO，DEBUG等改個名字 log4j.appender.CONSOLE=org.apach

MySQL— pymysql模組（防止sql注入），視覺化軟體Navicat

一.Pymysql import pymysql #python2.X 中是 mysqldb 和 pythonmysql 用法是一模一樣的 #pymysql可以偽裝成上面這兩個模組 user = input('username: ') pwd = input('passwo

【Java】sql實現插入，插入值的主鍵自增，防止遷移資料時報主鍵衝突的錯誤；

一、問題我們要自己造一些測試資料，並且這些SQL指令碼要遷移到其他環境，遷移過程中，如果主鍵寫死，在其他環境，可能會出現主鍵衝突；所以，我們要寫活的主鍵，實現起來也很簡單；二、解決方法 insert into userInfo(id,name,age)val

sql server 大批資料插入時，時間過長的問題

private const string con = "server=192.168.30.36;database=test;user=sa;pwd=123456"; static void Main(string[] args) { DataT

JDBC：使用PreparedStatement防止SQL注入

1.關於SQL注入什麼是SQL注入：由於jdbc程式在執行的過程中sql語句在拼裝時使用了由頁面傳入引數，如果使用者惡意傳入一些sql中的特殊關鍵字，會導致sql語句意義發生變化，這種攻擊方式就叫做sql注入，參考使用者註冊登入案例。首先看一下以下程式碼：

以mysql為例介紹PreparedStatement防止sql注入原理

最近，在寫程式時開始注意到sql注入的問題，由於以前寫程式碼時不是很注意，有一些sql會存在被注入的風險，那麼防止sql注入的原理是什麼呢？我們首先通過PrepareStatement這個類來學習一下吧！作為一個IT業內人士只要接觸過資料庫的人都應該知道sq

使用PreparedStatement 防止SQL攻擊實現預編譯功能提高效能

public boolean login(String username,String password) throws Exception { String driverClassName="com.mysql.jdbc.Driver"; S

較全面的php mysql封裝，使用mysqli物件支援預處理和事務，可輸出執行後的sql

下篇的文章已經更新咯，使用pdo安全性更高，相容性更強基於mysqli寫的sql封裝語句，可支援預處理和事務，可以輸出最後執行的sql。所有的條件以陣列傳遞即為預處理語句，否則為原始語句執行傳遞字串呼叫方法如下： $mysqlObj = new mysqliModel

【批量生成10萬條sql資料庫資料+IO流的使用】生成簡單sql插入語句大量資料，以及輸出流生成檔案2017年

第一步，建立一個java類，並且執行，在windows環境下 package com.test; import java.io.File; import java.io.FileOutputStream; import java.io.OutputStream; p

sql server建立儲存過程（有參，無參，有輸出）

student表已經有了，“建立”在中間，測試在最下面！ select * from student; sid sname sex age tel s001 豐登兒男 35 13527542451 s002 班克爾

PreparedStatement防止sql注入原理

PreparedStatement類是java的一個類，準確說是jdbc規範中的一個介面，各個資料庫產商的實現不同(即實現類不同)，今天我們就以mysql資料庫來說，我已經下載了mysql資料庫的驅動jar包和驅動程式的原始碼. sql注入的時候，比如，有些使用者就會在介面

在使用PreparedStatement防止SQL注入時，順帶輸出完整的SQL語句

原因：

程式碼：

呼叫並輸出：

相關推薦