sql语句：

select * from table1 where remark!='123'
查询结果：
 
id
name
remark
1
张三
1111
3
王五
222
 
原因：null 在=和<>之外，若要查询该数据也应该用 where remark is null
 解决方式：将该表中该字段的默认值设置为空字符串
 或新增保存数据时判断如果该字段传来的值为null，则将它改为空字符串
				
有时候进行数据库查询操作的时候，查询结果中一条参数或者有某几个参数为null，这种情况下，参数名都不会返回，解决办法如下：
第一种：mybatis返回值resultType="map" 改成实体类返回
第二种：还是用map接收，默认查询为控的字段不显示，
      所以在mybatis-config配置文件中加上setting
name="callSettersOnNul
4     and order_amount != '' 
5     and received_amount != null 
6     and received_amount != ''
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
public class SQLInjectionExample {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 创建连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/database", "username", "password");
            Scanner scanner = new Scanner(System.in);
            System.out.print("请输入表名：");
            String tableName = scanner.nextLine();
            // 使用PreparedStatement预处理语句，防止SQL注入
            String sql = "SELECT * FROM " + tableName;
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                // 处理查询结果
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                if (preparedStatement != null) {
                    preparedStatement.close();
                if (connection != null) {
                    connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
通过使用`PreparedStatement`预处理语句，我们可以有效的防止SQL注入漏洞的发生。  
### 回答2：
对于使用JDBC查询SQL语句，规避SQL注入漏洞且其中的表名是动态的，可以采用参数化查询的方式来实现。
代码示例：
```java
import java.sql.*;
public class JdbcDemo {
    public static void main(String[] args) {
        // 假设动态表名为tableName，替换为实际的表名
        String tableName = "your_dynamic_table_name";
        try {
            // 连接数据库
            Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/database", "username", "password");
            // 构造SQL语句
            String sql = "SELECT * FROM " + tableName + " WHERE id = ?";
            // 创建预编译的Statement对象
            PreparedStatement statement = connection.prepareStatement(sql);
            // 设置参数值
            statement.setInt(1, 1); // 假设需要查询id为1的记录，替换为实际需求
            // 执行查询
            ResultSet resultSet = statement.executeQuery();
            // 处理查询结果
            while(resultSet.next()) {
                // 获取数据，并进行相应处理
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                // 其他字段类似
                System.out.println("id: " + id + ", name: " + name);
            // 关闭资源
            resultSet.close();
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
上述代码中，使用PreparedStatement对象来进行参数化查询，即将动态的表名通过占位符的方式进行替换，从而避免了SQL注入漏洞的风险。
在SQL语句中使用`?`作为占位符，然后使用`setXxx()`方法来设置参数值，其中`Xxx`表示具体的数据类型，比如`setInt()`用于整型，`setString()`用于字符串等。这种方式可以确保SQL语句的安全性，同时提高了代码的可读性和可维护性。
需要注意的是，上述代码中的数据库连接信息以及动态的表名、参数值等都需要根据实际情况进行替换。  
### 回答3：
当我们使用JDBC查询SQL语句时，为了避免SQL注入漏洞，我们可以通过使用参数化查询来保护我们的代码。参数化查询是指将SQL语句中的参数用占位符替代，然后在执行查询时，将真正的参数值传递给占位符。
以下是一个示例代码，演示如何在JDBC中使用参数化查询，并规避SQL注入漏洞：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class JdbcExample {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            // 连接数据库
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username", "password");
            // 编写SQL语句，并将参数用问号代替
            String sql = "SELECT * FROM mytable WHERE column_name = ?";
            // 使用PreparedStatement对象来预编译SQL语句
            statement = connection.prepareStatement(sql);
            // 设置查询参数的值，这里使用了动态的标名
            statement.setString(1, "动态的标名");
            // 执行查询
            resultSet = statement.executeQuery();
            // 处理查询结果
            while (resultSet.next()) {
                // 操作结果集的字段数据
                String columnValue = resultSet.getString("column_name");
                System.out.println(columnValue);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                if (resultSet != null) {
                    resultSet.close();
                if (statement != null) {
                    statement.close();
                if (connection != null) {
                    connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
在上述代码中，通过使用PreparedStatement对象来预编译SQL语句，并使用`setString()`方法来设置查询参数的值。这样可以确保参数值不会直接被拼接到SQL语句中，从而有效地规避了SQL注入漏洞。