手写mybatis-预编译前的sql语句

news2024/11/13 15:21:10

sql表 mybatis数据库中的gxa_user表

/*
 Navicat Premium Data Transfer

 Source Server         : root
 Source Server Type    : MySQL
 Source Server Version : 80028
 Source Host           : localhost:3306
 Source Schema         : mybatis

 Target Server Type    : MySQL
 Target Server Version : 80028
 File Encoding         : 65001

 Date: 05/06/2024 20:48:12
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for gxa_user
-- ----------------------------
DROP TABLE IF EXISTS `gxa_user`;
CREATE TABLE `gxa_user`  (
  `id` bigint(0) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `salt` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `phone` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `created` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0),
  `last_login_time` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0),
  `status` int(0) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 47 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of gxa_user
-- ----------------------------
INSERT INTO `gxa_user` VALUES (1, '强哥', 'RbWEEsXVVxiR765qwusODQ==', 'e46d82f4-66b1-457d-8e70-36232b0a656e', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (2, '张老师', 'RbWEEsXVVxiR765qwusODQ==', 'e46d82f4-66b1-457d-8e70-36232b0a656e', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (3, '王国强', 'RbWEEsXVVxiR765qwusODQ==', 'e46d82f4-66b1-457d-8e70-36232b0a656e', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (11, '噗噗', '123456', '111', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (16, '噗噗2', '123456', '111', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (17, '补补', '123456', '111', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (20, '补补', '123456', '111', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (21, 'map', '8888', '222', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (23, 'map', '8888', '222', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (28, '123456', '12345', '123455', '123456', '2024-06-03 21:45:15', '2024-06-03 21:45:15', 1);
INSERT INTO `gxa_user` VALUES (29, 'gxaUser', '12345', '123455', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (30, 'mybatis', '12345', '123455', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (31, 'mybatis', '12345', '123455', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (32, 'mybatis', '12345', '123455', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (33, 'mybatisdemo', '123456', '11', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (34, 'mybatisdemo', '123456', '11', '123456789', '2024-06-03 21:42:18', '2024-06-03 21:42:18', 1);
INSERT INTO `gxa_user` VALUES (35, 'mybatisdemo', '123456', '11', '123568', '2024-06-03 21:47:49', '2024-06-03 21:47:49', 1);
INSERT INTO `gxa_user` VALUES (36, 'mybatisdemo', '123456', '11', '123568', '2024-06-03 21:50:22', '2024-06-03 21:50:22', 1);
INSERT INTO `gxa_user` VALUES (42, 'mybatis', '12345', '123455', '1234556', '2024-06-03 22:02:47', NULL, 1);
INSERT INTO `gxa_user` VALUES (43, 'mybatis', '12345', '123455', '1234556', '2024-06-03 22:04:07', '2024-06-03 22:04:07', 1);
INSERT INTO `gxa_user` VALUES (44, 'mybatis', '12345', '123455', '1234556', '2024-06-03 22:06:07', '2024-06-03 22:06:07', 1);
INSERT INTO `gxa_user` VALUES (45, 'mybatis', '12345', '123455', '1234556', '2024-06-05 14:38:22', '2024-06-05 14:38:22', 1);
INSERT INTO `gxa_user` VALUES (46, 'mybatis', '12345', '123455', '1234556', '2024-06-05 16:15:04', '2024-06-05 16:15:04', 1);

SET FOREIGN_KEY_CHECKS = 1;

jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=123456

准备五个注解放在annotation包里面

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Delete {
    String value() default "";
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Insert {
    String value() default "";
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Select {
    String value() default "";
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Update {
    String value() default "";
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Param {
    String value() default "";
}

配置数据库连接以及事务

import com.alibaba.druid.pool.DruidDataSource;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

public class JdbcUtils {
    public static DataSource dataSource;
    public static Properties properties=new Properties();
    public static ThreadLocal<Connection> threadLocal=new ThreadLocal<>();

    static {
        try {
            InputStream resourceAsStream = JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            properties.load(resourceAsStream);
            DruidDataSource druidDataSource = new DruidDataSource();
            druidDataSource.setDriverClassName(properties.getProperty("jdbc.driver"));
            druidDataSource.setUrl(properties.getProperty("jdbc.url"));
            druidDataSource.setUsername(properties.getProperty("jdbc.username"));
            druidDataSource.setPassword(properties.getProperty("jdbc.password"));
            dataSource=druidDataSource;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
    public static Connection getConnection(){
        try {
            if (threadLocal.get()==null)
                threadLocal.set(dataSource.getConnection());
                return threadLocal.get();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    public static void close(){
        if (threadLocal.get()!=null){
            try{
                threadLocal.get().close();
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("连接关闭失败");
            }
            threadLocal.set(null);
        }
    }
    public static void rollback(){
        if(threadLocal.get()!=null){
            try{
                threadLocal.get().rollback();
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("回滚失败");
            }
        }

    }
    public static void commit(){
        if (threadLocal.get()!=null){
            try{
                threadLocal.get().commit();
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("提交失败");
            }

        }

    }
    public static void start(){

            try{
                getConnection().setAutoCommit(false);
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("开启事务失败");
            }


    }

}

根据上面的表创建javabean实体类

/**
 * (GxaUser)实体类
 *
 * @author makejava
 * @since 2024-05-24 15:16:19
 */
public class GxaUser{
    
    private Long id;
    
    private String username;
    
    private String password;
    
    private String salt;
    
    private String phone;
    
    private LocalDateTime created;
    
    private LocalDateTime last_login_time;
    
    private Integer status;


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public LocalDateTime getCreated() {
        return created;
    }

    public void setCreated(LocalDateTime created) {
        this.created = created;
    }

    public LocalDateTime getLastLoginTime() {
        return last_login_time;
    }

    public void setLastLoginTime(LocalDateTime lastLoginTime) {
        this.last_login_time = lastLoginTime;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "GxaUser{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", salt='" + salt + '\'' +
                ", phone='" + phone + '\'' +
                ", created=" + created +
                ", lastLoginTime=" + last_login_time +
                ", status=" + status +
                '}';
    }
}

Dto传输参数给数据库的

public class GxaUserDto {

    
    private String username;
    
    private String password;
    
    private String salt;
    
    private String phone;
    
    private Date created;
    
    private Date last_login_time;
    
    private Integer status;



    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Date getCreated() {
        return created;
    }

    public void setCreated(Date created) {
        this.created = created;
    }

    public Date getLastLoginTime() {
        return last_login_time;
    }

    public void setLastLoginTime(Date lastLoginTime) {
        this.last_login_time = lastLoginTime;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "GxaUser{" +
                " username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", salt='" + salt + '\'' +
                ", phone='" + phone + '\'' +
                ", created=" + created +
                ", lastLoginTime=" + last_login_time +
                ", status=" + status +
                '}';
    }
}

mapper接口类

import com.ssj.annotation.Delete;
import com.ssj.annotation.Insert;
import com.ssj.annotation.Select;
import com.ssj.annotation.Update;
import com.ssj.entity.GxaUser;
import com.ssj.entity.GxaUserDto;
import com.ssj.entity.GxaUserDto2;

import java.util.HashMap;
import java.util.List;

public interface GxaUserMapper {
    @Select("Select * from gxa_user where id=?")
    GxaUser findUserById(Long id);
    @Select("Select * from gxa_user")
    List<GxaUser> findUser();
    @Insert("Insert into gxa_user(username,password,salt,phone,created,last_login_time,status)\n" +
            "        values(?,?,?,?,?,?,?)")
    int insertUser(GxaUserDto user);
    @Update("update gxa_user set username=? where id=?")
    int update(String username,Long id);
    @Delete("Delete from gxa_user where id=?")
    int delete(Long id);
}

sql语句预编译工具类


import java.util.ArrayList;
import java.util.List;


public class SQLUtils {


    /**
     * 将SQL字符串中的命名参数替换为"?"占位符。
     *
     * @param sql 包含命名参数的SQL查询字符串,格式为#{paramName}。
     * @param selectParams 要替换的参数名称列表。
     * @return 将命名参数替换为"?"占位符后的SQL查询字符串。
     */
    public static String replaceParam(String sql, List<Object> selectParams) {
        // 遍历参数名称列表
        for (int i = 0; i < selectParams.size(); i++) {
            // 获取当前的参数名称
            Object paramName = selectParams.get(i);
            // 将SQL字符串中出现的命名参数替换为"?"
            sql = sql.replace("#{" + paramName + "}", "?");
        }
        // 返回修改后的SQL字符串
        return sql;
    }

    /**
     * 将SQL字符串中的命名参数替换为"?"占位符。
     *
     * @param sql 包含命名参数的SQL查询字符串,格式为#{paramName}。
     * @param parameterName 要替换的参数名称数组。
     * @return 将命名参数替换为"?"占位符后的SQL查询字符串。
     */
    public static String replaceParam(String sql, String[] parameterName) {
        // 遍历参数名称数组
        for (int i = 0; i < parameterName.length; i++) {
            // 获取当前的参数名称并去除前后的空白字符
            String string = parameterName[i].trim();
            // 将SQL字符串中出现的命名参数替换为"?"
            sql = sql.replace("#{" + string + "}", "?");
        }
        // 返回修改后的SQL字符串
        return sql;
    }

    /**
     * 从SQL查询字符串的WHERE子句中提取参数名称列表。
     *
     * @param sql 包含WHERE子句和命名参数的SQL查询字符串。
     * @return 从WHERE子句中提取的参数名称列表。
     */
    public static List<Object> getSelectParams(String sql) {
        List<Object> paramList = new ArrayList<>();

        // 查找WHERE子句的起始索引
        int whereIndex = sql.toLowerCase().indexOf("where");
        if (whereIndex == -1) {
            // 如果没有WHERE子句,返回空列表
            return paramList;
        }

        // 从SQL字符串中提取WHERE子句
        String whereClause = sql.substring(whereIndex + 5).trim();
        if (whereClause.isEmpty()) {
            // 如果WHERE子句为空,返回空列表
            return paramList;
        }

        // 按"and"分割WHERE子句,得到各个条件
        String[] paramsStrs = whereClause.split("\\s+and\\s+");
        // 遍历每个条件
        for (String paramsStr : paramsStrs) {
            // 按"="分割条件,提取参数
            if (paramsStr.contains("=")) {
                String[] parts = paramsStr.split("=");
                if (parts.length == 2) {
                    String param = parts[1].replace("#{", "").replace("}", "").trim();
                    if (!param.isEmpty()) {
                        // 将参数名称添加到列表中
                        paramList.add(param);
                    }
                }
            }
        }
        // 返回参数名称列表
        return paramList;
    }

    /**
     * 从INSERT SQL查询字符串的VALUES子句中提取参数名称列表。
     *
     * @param sql 包含INSERT语句和命名参数的SQL查询字符串。
     * @return 从VALUES子句中提取的参数名称数组。
     */
    public static String[] getInsertParams(String sql) {
        // 查找VALUES子句的起始索引
        int startIndex = sql.indexOf("values");
        // 从SQL字符串中提取VALUES子句,去除参数名称中的#{和},并去除括号
        String values = sql.substring(startIndex + 6).replaceAll("#\\{", "").replaceAll("}", "").
                replace("(", "").replace(")", "");
        // 按逗号分割清理后的VALUES子句,得到各个参数名称
        return values.split(",");
    }

    public static List<Object> getUpdateParams(String sql) {
        List<Object> paramList = new ArrayList<>();

        // 查找SET子句的起始索引
        int setStartIndex = sql.toLowerCase().indexOf("set") + 3;
        int whereStartIndex = sql.toLowerCase().indexOf("where");

        // 如果没有WHERE子句
        if (whereStartIndex == -1) {
            // 提取整个SET子句
            String setClause = sql.substring(setStartIndex).trim();
            addSetParams(paramList, setClause);
        } else {
            // 提取SET子句中的参数
            String setClause = sql.substring(setStartIndex, whereStartIndex).trim();
            addSetParams(paramList, setClause);

            // 提取WHERE子句中的参数
            String whereClause = sql.substring(whereStartIndex + 5).trim();
            addWhereParams(paramList, whereClause);
        }

        return paramList;

    }
    // 辅助方法:提取SET子句中的参数
    private static void addSetParams(List<Object> paramList, String setClause) {
        String[] setParams = setClause.split(",");
        for (String setParam : setParams) {
            String param = setParam.split("=")[1].replace("#{", "").replace("}", "").trim();
            paramList.add(param);
        }
    }
    // 辅助方法:提取WHERE子句中的参数
    private static void addWhereParams(List<Object> paramList, String whereClause) {
        String[] whereParams = whereClause.split("\\s+and\\s+");
        for (String whereParam : whereParams) {
            if (whereParam.contains("=")) {
                String[] parts = whereParam.split("=");
                if (parts.length == 2) {
                    String param = parts[1].replace("#{", "").replace("}", "").trim();
                    if (!param.isEmpty()) {
                        paramList.add(param);
                    }
                }
            }
        }
    }
}

jdk动态地理实现上面mapper接口

import com.ssj.annotation.*;

import java.lang.reflect.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

public class MybatisUtils {
    public static <T> T getMapper(Class<T> clazz) {
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("该 " + method.getName() + " 方法被调用了");
                if (method.isAnnotationPresent(Insert.class)) {
                    Insert annotation = method.getAnnotation(Insert.class);
                    String sql = annotation.value();
                    return executeInsert(method,sql, args);
                } else if (method.isAnnotationPresent(Delete.class)) {
                    Delete annotation = method.getAnnotation(Delete.class);
                    String sql = annotation.value();
                    return executeDelete(method,sql, args);
                } else if (method.isAnnotationPresent(Update.class)) {
                    Update annotation = method.getAnnotation(Update.class);
                    String sql = annotation.value();
                    return executeUpdate(method,sql, args);
                } else if (method.isAnnotationPresent(Select.class)) {
                    Select annotation = method.getAnnotation(Select.class);
                    String sql = annotation.value();
                    return executeQuery(sql, args, method);
                }
                return null;
            }

            private int executeInsert(Method method,String sql, Object[] args) throws Exception {
                if (args.length == 0) {
                    System.out.println("args长度为0");
                    throw new IllegalArgumentException("Invalid argument for insert operation");
                }
                //插入参数
                String[] insertParam = SQLUtils.getInsertParams(sql);
                //参数绑定
                ConcurrentHashMap<String, Object> paramMap = getMethodParam(method, args);
                //将参数值加入list
                List<Object> paramValueList = addParamToList(insertParam, paramMap);
                //预编译sql语句
                sql = SQLUtils.replaceParam(sql, insertParam);

                try (Connection connection = JdbcUtils.getConnection();
                     PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
                    JdbcUtils.start();
//                    setPreparedStatementParameters(preparedStatement, args[0]);
                    if (paramValueList!=null){
                        // 设置PreparedStatement参数
                        for (int i = 0; i < paramValueList.toArray().length; i++) {
                            // 将方法参数设置到PreparedStatement中
                            preparedStatement.setObject(i + 1, paramValueList.get(i));
                        }
                    }

                    int rows = preparedStatement.executeUpdate();
                    JdbcUtils.commit();
                    return rows;
                }catch (Exception e){
                    JdbcUtils.rollback();
                    JdbcUtils.commit();
                    e.printStackTrace();
                    throw new RuntimeException("数据库连接异常");
                }finally {
                    JdbcUtils.close();
                }
            }
            private int executeUpdate(Method method,String sql, Object[] args) throws Exception {
                //插入参数
                List<Object> insertParam = SQLUtils.getUpdateParams(sql);
                //参数绑定
                ConcurrentHashMap<String, Object> paramMap = getMethodParam(method, args);
                //将参数值加入list
                List<Object> paramValueList = addParamToList(insertParam, paramMap);
                //预编译sql语句
                sql = SQLUtils.replaceParam(sql, insertParam);
                try (Connection connection = JdbcUtils.getConnection();
                     PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
                    JdbcUtils.start();
                    for (int i = 0; i < paramValueList.toArray().length; i++) {
                        System.out.println("修改参数: " + args[i]);
                        preparedStatement.setObject(i + 1, paramValueList.get(i));
                    }

                    int rows = preparedStatement.executeUpdate();
                    JdbcUtils.commit();
                    return rows;
                } catch (Exception e) {
                    JdbcUtils.rollback();
                    throw e;
                } finally {
                    JdbcUtils.close();
                }
            }
            private int executeDelete(Method method,String sql, Object[] args) throws Exception {
                //插入参数
                List<Object> insertParam = SQLUtils.getSelectParams(sql);
                //参数绑定
                ConcurrentHashMap<String, Object> paramMap = getMethodParam(method, args);
                //将参数值加入list
                List<Object> paramValueList = addParamToList(insertParam, paramMap);
                //预编译sql语句
                sql = SQLUtils.replaceParam(sql, insertParam);
                try (Connection connection = JdbcUtils.getConnection();
                     PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
                    JdbcUtils.start();
                    for (int i = 0; i < paramValueList.toArray().length; i++) {
                        System.out.println("删除参数: " + args[i]);
                        preparedStatement.setObject(i + 1, paramValueList.get(i));
                    }

                    int rows = preparedStatement.executeUpdate();
                    JdbcUtils.commit();
                    return rows;
                } catch (Exception e) {
                    JdbcUtils.rollback();
                    throw e;
                } finally {
                    JdbcUtils.close();
                }
            }

            // 执行查询操作
            private Object executeQuery(String sql, Object[] args, Method method) throws Exception {
                //插入参数
                List<Object> selectParams = SQLUtils.getSelectParams(sql);
                //参数绑定
                ConcurrentHashMap<String, Object> paramMap = getMethodParam(method, args);
                //将参数值加入list
                List<Object> paramValueList = addParamToList(selectParams, paramMap);
                //预编译sql语句
                sql = SQLUtils.replaceParam(sql, selectParams);
                try (Connection connection = JdbcUtils.getConnection();
                     PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
                    System.out.println("args.length="+args);
                    if (args!=null){
                        // 设置PreparedStatement参数
                        for (int i = 0; i < paramValueList.toArray().length; i++) {
                            // 将方法参数设置到PreparedStatement中
                            preparedStatement.setObject(i + 1, paramValueList.get(i));
                        }
                    }
                    // 执行查询操作
                    ResultSet resultSet = preparedStatement.executeQuery();

                    // 获取方法的返回类型
                    Class<?> returnType = method.getReturnType();
                    // 如果返回类型是List,则将结果集映射为List对象
                    if (returnType == List.class) {
                        return mapResultSetToList(resultSet, getGenericReturnType(method));
                    } else {
                        // 如果不是List,则将结果集映射为单个对象
                        if (resultSet.next()) {
                            return mapResultSetToObject(resultSet, returnType);
                        }
                    }
                    return null;
                }catch (Exception e){
                    e.printStackTrace();
                    throw new RuntimeException("数据库连接异常");
                }finally {
                    JdbcUtils.close();
                }
            }

            private void setPreparedStatementParameters(PreparedStatement preparedStatement, Object param) throws Exception {
                System.out.println(param);
                Class<?> clazz = param.getClass();
                Field[] fields = clazz.getDeclaredFields();
                int index = 1;

                for (Field field : fields) {
                    field.setAccessible(true);
                    Object value = field.get(param);
                    System.out.println("insert--- 参数:"+value);
//                    if (value==null) continue;
                    preparedStatement.setObject(index++, value);
                }
            }



            // 将ResultSet映射为对象列表
            private <T> List<T> mapResultSetToList(ResultSet resultSet, Class<T> clazz) throws Exception {
                List<T> list = new ArrayList<>();
                // 遍历结果集,将每行数据映射为对象并添加到列表中
                while (resultSet.next()) {
                    list.add(mapResultSetToObject(resultSet, clazz));
                }
                return list;
            }

            // 将ResultSet映射为单个对象
            private <T> T mapResultSetToObject(ResultSet resultSet, Class<T> clazz) throws Exception {
                T obj = clazz.getDeclaredConstructor().newInstance();
                ResultSetMetaData metaData = resultSet.getMetaData();
                // 遍历结果集的元数据,将每列的数据映射到对象的相应字段中
                for (int i = 1; i <= metaData.getColumnCount(); i++) {
                    String columnName = metaData.getColumnName(i);
                    Field field = clazz.getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(obj, resultSet.getObject(i));
                }
                return obj;
            }

            // 获取方法的泛型返回类型
            private Class<?> getGenericReturnType(Method method) {
                Type returnType = method.getGenericReturnType();
                // 如果返回类型是参数化类型,则获取实际的类型参数
                if (returnType instanceof ParameterizedType) {
                    ParameterizedType parameterizedType = (ParameterizedType) returnType;
                    return (Class<?>) parameterizedType.getActualTypeArguments()[0];
                }
                return Object.class;
            }
            // 判断一个类是否为基本类型或包装类型
            private  boolean isPrimitiveOrWrapper(Class<?> type) {
                return type.isPrimitive() || type == Boolean.class || type == Byte.class ||
                        type == Character.class || type == Double.class || type == Float.class ||
                        type == Integer.class || type == Long.class || type == Short.class ||
                        type == String.class;
            }

            private ConcurrentHashMap<String, Object> getMethodParam(Method method, Object[] args) {
                ConcurrentHashMap<String, Object> paramMap = new ConcurrentHashMap<>();
                Parameter[] parameters = method.getParameters();
                for (int i = 0; i < parameters.length; i++) {
                    Param param = parameters[i].getAnnotation(Param.class);
                    if (param == null) {
                        continue;
                    }
                    String paramName = param.value();
                    System.out.println("paramName="+paramName);
                    Object paramValue = args[i];
                    System.out.println("paramValue="+paramValue);

                    // 如果参数不是基本类型或包装类型,则将其属性名和值添加到 paramMap 中
                    if (!isPrimitiveOrWrapper(paramValue.getClass())) {
                        addObjectFieldsToParamMap(paramMap, paramName, paramValue);
                    } else {
                        paramMap.put(paramName, paramValue);
                    }
                }
                return paramMap;
            }

            // 将对象的属性名和值添加到 paramMap 中
            private void addObjectFieldsToParamMap(ConcurrentHashMap<String, Object> paramMap, String paramName, Object paramValue) {
                Field[] fields = paramValue.getClass().getDeclaredFields();
                for (Field field : fields) {
                    field.setAccessible(true);
                    try {
                        Object fieldValue = field.get(paramValue);
                        System.out.println("filedValue="+fieldValue);
                        String fieldName = paramName + "." + field.getName();
                        System.out.println("fieldName="+fieldName.substring(fieldName.indexOf(".")+1));
                        paramMap.put(fieldName.substring(fieldName.indexOf(".")+1), fieldValue);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
            private List<Object> addParamToList(String[] insertParam, ConcurrentHashMap<String, Object> paramMap) {
                List<Object> paramValueList = new ArrayList<>();
                for (String param : insertParam) {
                    Object paramValue = paramMap.get(param.trim());
                    paramValueList.add(paramValue);
                }
                return paramValueList;
            }
            private List<Object> addParamToList(List<Object> insertParam, ConcurrentHashMap<String, Object> paramMap) {
                List<Object> paramValueList = new ArrayList<>();
                for (Object param : insertParam) {
                    Object paramValue = paramMap.get(param);
                    paramValueList.add(paramValue);
                }
                return paramValueList;
            }

        });
    }
}

在这里插入图片描述

项目结构

在这里插入图片描述
完整代码,请移步gitee
https://gitee.com/xiaobei_xiaohe/mybatisDemo2

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1808426.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

论文略读:Onthe Expressivity Role of LayerNorm in Transformers’ Attention

ACL 2023 研究了LayerNorm在 Transformers 中对注意力的作用LayerNorm为Transformer的Attention提供了两个重要的功能&#xff1a; 投影&#xff0c;projection LayerNorm 帮助 Attention 设计一个注意力查询&#xff0c;这样所有的Key都可以平等地访问通过将Key向量投影到同一…

域内攻击 ----> DCSync

其实严格意义上来说DCSync这个技术&#xff0c;并不是一种横向得技术&#xff0c;而是更偏向于权限维持吧&#xff01; 但是其实也是可以用来横向&#xff08;配合NTLM Realy&#xff09;&#xff0c;如果不牵强说得话&#xff01; 那么下面&#xff0c;我们就来看看这个DCSyn…

Vue学习|Vue快速入门、常用指令、生命周期、Ajax、Axios

什么是Vue? Vue 是一套前端框架&#xff0c;免除原生JavaScript中的DOM操作&#xff0c;简化书写 基于MVVM(Model-View-ViewModel)思想&#xff0c;实现数据的双向绑定&#xff0c;将编程的关注点放在数据上。官网:https://v2.cn.vuejs.org/ Vue快速入门 打开页面&#xff0…

rce漏洞试试看 buuctf的pingpingping 试试ctf的rce怎么样

打开靶机开始操作 然后我们先知道一些知识点&#xff1a;下面这些是常用的 |这个管道符也就是上一条的命令的输出结果作为下一条命令的输入&#xff1b;这个是跟sql的堆叠注入是一样的|| || 当前面的执行出错时&#xff08;为假&#xff09;执行后面的 & 将任务置于后台执…

R语言绘图 --- 桑基图(Biorplot 开发日志 --- 5)

「写在前面」 在科研数据分析中我们会重复地绘制一些图形&#xff0c;如果代码管理不当经常就会忘记之前绘图的代码。于是我计划开发一个 R 包&#xff08;Biorplot&#xff09;&#xff0c;用来管理自己 R 语言绘图的代码。本系列文章用于记录 Biorplot 包开发日志。 相关链接…

从Log4j和Fastjson RCE漏洞认识jndi注入

文章目录 前言JNDI注入基础介绍靶场搭建漏洞验证注入工具 log4j RCE漏洞分析漏洞靶场检测工具补丁绕过 Fastjson RCE漏洞分析漏洞靶场检测工具补丁绕过 总结 前言 接着前文的学习《Java反序列化漏洞与URLDNS利用链分析》&#xff0c;想了解为什么 Fastjson 反序列化漏洞的利用…

如何制定工程战略

本文介绍了领导者如何有效制定工程战略&#xff0c;包括理解战略核心、如何收集信息并制定可行的策略&#xff0c;以及如何利用行业最佳实践和技术债务管理来提升团队效能和产品质量。原文: How to Build Engineering Strategy 如果你了解过目标框架&#xff08;如 OKR&#xf…

引人入胜的教育视频

对于一家专注于数字自动化和能源管理的跨国公司&#xff0c;我们制作了引人入胜的教育视频&#xff0c;帮助房主选择适合他们需求的电气产品。我们的团队审查并定稿文本&#xff0c;录制并编辑配音&#xff0c;选择背景音乐&#xff0c;设计图形&#xff0c;并制作了演示如何安…

MPB | 葛体达组-原位酶谱法高分辨率实时检测土壤微界面酶活分布

原位酶谱法高分辨率实时检测土壤微界面酶活分布 High resolution real-time detection of soil enzyme activity distribution by in situ zymography 魏晓梦1, 2、魏亮1, 2、郝存抗1, 2、祝贞科1, 2、吴金水1, 2、葛体达1, 2, * 1中国科学院亚热带农业生态研究所&#xff0c;中…

04-认识微服务-SpringCloud

04-认识微服务-SpringCloud 1.SpringCloud&#xff1a; 1.SpringCloud是目前国内使用最广泛的微服务框架。官网地址&#xff1a;https://spring.io/projects/spring-cloud 2.SpringCloud集成了各种微服务功能组件&#xff0c;并基于SpringBoot实现了这些组件的自动装配&…

Vue3学习记录第三天

Vue3学习记录第三天 背景说明学习记录Vue3中shallowReactive()和shallowRef()Vue3中toRaw()和markRaw()前端...语法Vue3中readonly()和shallowReadonly()函数 背景 之前把Vue2的基础学了, 这个课程的后面有简单介绍Vue3的部分. 学习知识容易忘, 这里仅简答做一个记录. 内容都很…

10-Feign-最佳实践分析

10-Feign-最佳实践分析 1.Feign的最佳实践: 方式一(继承):给消费者的FeignClient和提供者的controller定义统一的父接口作为标准。 ​ 服务紧耦合 ​ 父接口参数列表中的映射不会被继承下来 Spring官方不推荐这种方式: ​ 我们一般不推荐去共享接口在服务端和客户端…

【web性能】什么是图层?图层创建的条件?

CSS图层 浏览器在渲染一个页面时&#xff0c;会将页面分为很多个图层&#xff0c;图层有大有小&#xff0c;每个图层上有一个或多个节点。在渲染DOM的时候&#xff0c;浏览器所做的工作实际上是&#xff1a; 获取DOM后分割为多个图层&#xff1b;对每个图层的节点计算样式结果…

数据结构和算法之数组和链表

一、数组 数组是一种线性数据结构&#xff0c;它是由一组连续的内存单元组成的&#xff0c;用于存储相同类型的数据。在JavaScript中&#xff0c;数组可以包含任意类型的数据&#xff0c;不只限于基本数据类型。 1.存储方式 在内存中&#xff0c;数组的元素是连续存储的&…

Java 期末复习 习题集

&#x1f496; 单选题 &#x1f496; 填空题 &#x1f496; 判断题 &#x1f496; 程序阅读题 1. 读代码写结果 class A {int m 5;void zengA(int x){m m x;}int jianA(int y){return m - y;} }class B extends A {int m 3;int jianA(int z){return super.jianA(z) m;} …

【内存管理】页表映射

页表的一些术语 现在Linux内核中支持四级页表的映射&#xff0c;我们先看下内核中关于页表的一些术语&#xff1a; 全局目录项&#xff0c;PGD&#xff08;Page Global Directory&#xff09; 上级目录项&#xff0c;PUD&#xff08;Page Upper Directory&#xff09; 中间目…

Python openpyxl 库使用详解

大家好&#xff0c;当谈论处理 Excel 文件时&#xff0c;Python 的 openpyxl 库无疑是一个强大而灵活的工具。无论是在数据分析、报告生成还是自动化任务中&#xff0c;openpyxl 都展现出了其独特的价值。本文将详细介绍 openpyxl 库的各种功能和用法&#xff0c;帮助读者掌握如…

在idea中创建Scala项目教程

1.下载Scala支持插件 文件-设置-插件-marketplace 搜索Scala 下载 2.创建项目 文件-新建-项目-新项目-构建系统maven 3.创建Scala目录 Scr-main(右键)-新建-目录&#xff08;Scala回车键&#xff09;-scala(右键)-将项目标记为-源代码根目录 4.对当前项目引入Scala支持 未添…

mysql设置允许外部ip访问,局域网IP访问

&#xff08;支持MYSQL8版本&#xff09; 1. 登录进入mysql&#xff1b;mysql -uroot -p输入密码进入 2. 输入以下语句&#xff0c;进入mysql库&#xff0c;查看user表中root用户的访问 use mysql; select host,user from user; 3. 更新user表中root用户域属性&#xff0c…

CST Studio Suite 2020 软件安装教程、安装包下载

CST Studio Suite 2020 安装教程 安装包下载 复制链接在浏览器打开 https://www.qqres.com/3150.html CST Studio Suite 是由Dassault Systmes公司开发的一套电磁场仿真软件。它应用于电子、通信、天线设计、射频与微波、电磁兼容性 (EMC)、电磁干扰 (EMI) 等领域。 CST St…