jdbc20230525（自用记录）

已于 2023-11-16 17:25:01 修改
阅读量3.5k 收藏
点赞数
文章标签： java junit mybatis
于 2023-05-26 14:24:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69881606/article/details/130885549
版权 
package com.test;

import cn.hutool.json.JSONUtil;
import org.junit.Test;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class SqlTest {
    @Test
    public void testMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("sex", "0");
        map.put("sex1", "1");
        System.out.println(map.get("sex"));
        System.out.println(map.get("sex1"));
    }

//通过map插入
    @Test
    public void insertByMap() {
        Map<String, Object> paranMap = new HashMap<>();
        paranMap.put("id", String.valueOf(System.currentTimeMillis()));
        paranMap.put("name", "小张");
        paranMap.put("sex", "0");
        paranMap.put("phone", "17362162267");

        String sql = "insert into user (id,name,sex,phone) values(#{id},#{name},#{sex},#{phone})";
        Connection con = DBUtil.connectDB();
        boolean row1 = DBUtil.insertByMap(con, sql,
                paranMap);
        System.out.println("insertByBean 查询结果：" + row1);
        DBUtil.close(con);

    }


    public static void main(String[] args) throws Exception {
        //连接
        Connection con = DBUtil.connectDB();
        // 通过bean插入
        User users = new User();
        users.setId(String.valueOf(System.currentTimeMillis()));
        users.setName("小方1");
        users.setAge("10");
        users.setSex("男");
        users.setPhone("8708979898");
        boolean row1 = DBUtil.insertByBean(con, "insert into user (id,name,sex,phone) values(#{id},#{name},#{sex},#{phone})",
                users);
        System.out.println("insertByBean 查询结果：" + row1);
        DBUtil.close(con);


         //查询，结果为类
        List<User> users = DBUtil.queryListToBean(con, "select * from user", User.class);
        System.out.println("queryListToBean 查询结果：" + JSONUtil.toJsonStr(users));


       //查询，结果为List
        List<Map<String, Object>> resultMapList = DBUtil.queryList(con, "select * from user");
        System.out.println("queryList 查询结果：" + JSONUtil.toJsonStr(resultMapList));
       
       //插入一条记录
         boolean row = DBUtil.insert(con, "insert into user (id,name,sex,phone) values(?,?,?,?)",
                String.valueOf(System.currentTimeMillis()), "小明", "男", "1123123213");
        System.out.println("insert 查询结果：" + row);
    }
}

package com.test;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;

public class DBUtil {
    private static String URL = "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
    private static String Driver = "com.mysql.jdbc.Driver";
    private static String user = "root";
    private static String password = "666666";

    public static void main(String[] args) throws Exception {
        String s = "insert into user (id,name,sex,phone) values(#{id},#{name},#{sex},#{phone})";
        List<String> param = new ArrayList<>();
        //返回#在字符串中的位置
        while (s.contains("#{")) {
            int i = s.indexOf("#{");
            int i2 = s.indexOf("}");
            //从下标0开始截取，截取到i；从下标i2+1开始截取，截取到末尾
            String substring = s.substring(0, i) + "?" + s.substring(i2 + 1);
            //截取param
            String paramstring = s.substring(i + 2, i2);
            param.add(paramstring);
            System.out.println(substring);
            s = substring;
        }
        System.out.println(param);
//截取sql语句，将#{}替换成？，结果s = "insert into user (id,name,sex,phone) values(？，？，？，？)"
    }

    public void test1() throws Exception {
        /* 加载驱动 */
        Class.forName(Driver);
        /* 创建连接， */
        Connection conn = DriverManager.getConnection(URL, user, password);
        /* sql 预处理 */
        PreparedStatement preparedStatement = conn.prepareStatement("select * from user");
        // preparedStatement.setString(1, "1");
        /* 执行sql */
        ResultSet resultSet = preparedStatement.executeQuery();
        // 解析数据
        ResultSetMetaData rsmd = resultSet.getMetaData();
        int count = rsmd.getColumnCount();
        String[] name = new String[count];
        // ColumnNames : [id, name, age, sex, phone]
        for (int i = 0; i < count; i++) {
            name[i] = rsmd.getColumnName(i + 1);
            System.out.println(rsmd.getColumnType(i + 1));
        }
        List<Map<String, Object>> resultList = new ArrayList<>();
        List<User> resultUserList = new ArrayList<>();

        System.out.println("ColumnNames : " + Arrays.toString(name));
        while (resultSet.next()) {
            Map rowData = new HashMap();
            for (int i = 1; i <= count; i++) {
                rowData.put(rsmd.getColumnName(i), resultSet.getObject(i));
            }
            resultList.add(rowData);
            System.out.println();
            for (String s : name) {
                Object string = resultSet.getObject(s);
                System.out.print(s + ":" + string + ";");
            }

        }
        //关闭数据库连接
        resultSet.close();
        preparedStatement.close();
        conn.close();
    }

    //连接
    public static Connection connectDB() {
        try {
            Class.forName(Driver);
            Connection conn = DriverManager.getConnection(URL, user, password);
            return conn;
        } catch (Exception e) {
            throw new RuntimeException();
        }
    }

    //泛型T
    public static <T> List<Map<String, Object>> queryList(Connection con, Class<T> Objclass, String s) {
        try {
            T t = Objclass.newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return null;
    }

    //查询，结果为类
    public static <T> List<T> queryListToBean(Connection con, String s, Class<T> tClass) {
        List<T> resultList;
        try {
            resultList = new ArrayList<>();
            PreparedStatement ps = con.prepareStatement(s);
            ResultSet resultSet = ps.executeQuery(s);
            ResultSetMetaData rsmd = resultSet.getMetaData();
            int count = rsmd.getColumnCount();
            while (resultSet.next()) {
                // java 反射
                T t = tClass.newInstance();
                for (int i = 1; i <= count; i++) {
                    Field declaredField = tClass.getDeclaredField(rsmd.getColumnName(i));
                    declaredField.setAccessible(true);
                    declaredField.set(t, resultSet.getObject(i));
                    // 关闭允许访问
                    declaredField.setAccessible(false);
                }
                resultList.add(t);
            }
            try {
                resultSet.close();
                ps.close();
            } catch (Exception ignored) {
        }
     } catch (Exception e) {
            throw new RuntimeException();
   }
        return resultList;
 }

    //查询,结果为List
    public static List<Map<String, Object>> queryList(Connection con, String s) {
        List<Map<String, Object>> resultList;
        try {
            resultList = new ArrayList<>();
            PreparedStatement ps = con.prepareStatement(s);
            ResultSet resultSet = ps.executeQuery(s);
            ResultSetMetaData rsmd = resultSet.getMetaData();
            int count = rsmd.getColumnCount();
            while (resultSet.next()) {
                Map<String, Object> rowData = new HashMap<>();
                for (int i = 1; i <= count; i++) {
                    rowData.put(rsmd.getColumnName(i), resultSet.getObject(i));
                }
                resultList.add(rowData);
            }
            try {
                resultSet.close();
                ps.close();
            } catch (Exception ignored) {

            }
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return resultList;
    }

    /**
     * User user = new User();
     * //                    Field[] fields = User.class.getDeclaredFields();
     * //                    for (Field field : fields) {
     * //                        // 设置允许访问
     * //                        field.setAccessible(true);
     * //                        field.set(user,field.getName()+"value");
     * //                        // 关闭允许访问
     * //                        field.setAccessible(false);
     * //                    }
     * //                    // {"sex":"sexvalue","phone":"phonevalue","name":"namevalue","id":"idvalue","age":"agevalue"}
     * //                    System.out.println(JSONUtil.toJsonStr(user));
     */

    public static void close(Connection con) {
        try {
            con.close();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //插入一条信息，多个参数
    public static boolean insert(Connection con, String s, Object... param) {
        try {
            PreparedStatement ps = con.prepareStatement(s);
            // param.length = 4
            for (int i = 0; i < param.length; i++) {
                ps.setObject(i + 1, param[i]);
            }
            int update = ps.executeUpdate();
            if (update >= 1) {
                return true;
            }
            try {
                ps.close();
                con.close();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return false;
    }

//通过bean插入，参数是object
    public static boolean insertByBean(Connection con, String sql, Object dataObj) {
        try {
            // 参数名称数组
            List<String> paramNameList = new ArrayList<>();
            //截取sql语句，并且将值放在paramNameList中
            sql = handleSql(sql, paramNameList);
            /**
             * insert into user (id,name,sex,phone) values(?,?,?,?)
             * [id, name, sex, phone]
             */
            PreparedStatement ps = con.prepareStatement(sql);
            // param.length = 4
            for (int i = 0; i < paramNameList.size(); i++) {
                String paramName = paramNameList.get(i);
                Class<?> aClass = dataObj.getClass();
                // id
                Field declaredField = aClass.getDeclaredField(paramName);
                declaredField.setAccessible(true);
                Object val = declaredField.get(dataObj);
                // 关闭允许访问
                declaredField.setAccessible(false);
                ps.setObject(i + 1, val);
            }
            int update = ps.executeUpdate();
            if (update >= 1) {
                return true;
            }
            try {
                ps.close();
                con.close();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return false;
    }

    static String handleSql(String sql, List<String> param) {
        //返回#在字符串中的位置
        while (sql.contains("#{")) {
            int i = sql.indexOf("#{");
            int i2 = sql.indexOf("}");
            //从下标0开始截取，截取到i；从下标i2开始截取，截取到末尾
            String substring = sql.substring(0, i) + "?" + sql.substring(i2 + 1);
            //截取param
            String paramstring = sql.substring(i + 2, i2);
            param.add(paramstring);
            System.out.println(substring);
            sql = substring;
        }
        System.out.println(param);
        return sql;
    }



    public static boolean insertByMap(Connection con, String sql, Map<String, Object> paranMap) {
        try {
            // 参数名称数组 []
            List<String> paramNameList = new ArrayList<>();
            // 处理sql
            sql = handleSql(sql, paramNameList);
            /**
             * sql =   insert into user (id,name,sex,phone) values(?,?,?,?)
             * paramNameList  =  [id, name, sex, phone]
             *
             *
             *         paranMap.put("id1", String.valueOf(System.currentTimeMillis()));
             *         paranMap.put("name", "小张");
             *         paranMap.put("sex", "0");
             *         paranMap.put("phone", "17362162267");
             *
             */
            PreparedStatement ps = con.prepareStatement(sql);
          /*  ps.setObject(1,paranMap.get("id"));
            ps.setObject(2,paranMap.get("name"));
            ps.setObject(3,paranMap.get("sex"));
            ps.setObject(4,paranMap.get("phone"));*/
            //通过i代表的键，获得对于paranMap中的值
            for (int i=0;i<paramNameList.size();i++){
                ps.setObject(i+1,paranMap.get(paramNameList.get(i)));
            }
            int update = ps.executeUpdate();
            if (update >= 1) {
                return true;
            }
            try {
                ps.close();
                con.close();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return false;
    }
}

dodo551
关注
jdbc学习中出现的问题（自用）
qq_43130076的博客
12-07 230
以下问题为自己编程过程中遇到的问题，如果各路神通觉得我出现的问题比较低级。可以给出解决意见，但不要乱喷。心灵脆弱禁不起打击，本博作为我编程路上跳坑记录，学会之后会过来填平。但不知道什么时候才能学会。 1、针对一张表查询一条数据的通用方法 实体类 package com.company.preparedstatement.crud; public class course { public String CId; public String Cname; public String
JDBC及数据库连接池 自用解析
cq724165616的博客
03-07 265
JDBC： 1. 概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库 * JDBC本质：是一套操作所有关系型数据库的规则，即接口。数据库公司去实现这套接口，提供jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。 2. 快速入门： * 步骤： 1. 导入驱动jar包 ...
JDBC（自用）
qq_45906102的博客
03-11 124
没有JDBC的时候，如果现在要开发一套系统，使用Java连接MySQL数据库，那么这时候Java程序员需要了解MySQL驱动API，如果使用Java连接Oracle数据库，那么这个时候Java程序员需要了解Oracle数据库驱动API。 SUN公司提供一套统一的规范（接口）。然后各个数据库生产商提供这套接口的实现。这套接口规范就是JDBC的规范。 快速入门 ...
JDBC笔记（自用）
weixin_46427348的博客
03-15 884
JDBC 在Java中 ,数据库存取技术客服呢为如下几类： 1.JDBC 直接访问数据库 2.JDO（java data object）技术 3.第三方O/R工具 , 如Hibernate，Mybatis 等 JDBC是JAVA访问数据库的基石，JDO Hibernate MyBatis 等只是更好封装了JDBC JDBC 是一个独立于特定数据库管理系统 通用的SQL数据库存取和操作的公共接口 ，定义了用来访问数据库的标准java类库,使用这些类库可以以一种标准的方法方便地访问数据库资源。 ...
JDBC(自用)
qq_40064635的博客
01-11 121
jdbc jdbc：java database connction。是java连接数据库的一套标准。该标准提供了一系列 的接口，由数据库厂商实现。开发者更具接口调用厂商实现的方法。这样，无论连接什么 样的数据库都是一条API。 orm：jdbc本质是流操作。完成是内存数据和磁盘数据的转换。对于Java而言，内存数据由对象表示，对于数据库而言，磁盘数据由数据库表来表示。所谓ORM就是对象和关系数据的...
jdbc连接数据库和一些实例，自用
math666的专栏
04-18 179
https://github.com/Snailclimb/JavaGuide#%E5%9F%BA%E7%A1%80 需要jar包：mysql-connector-java-5.1.15-bin.jar package com.mymvc.converters; import java.sql.Connection; import java.sql.DriverManager; import...
JDBC工具类Java反射封装（自用）
weixin_45947759的博客
06-29 198
public class JDBCUtils { private static String driver; private static String url; private static String user; private static String password; private static DruidDataSource druidDataSource; /** * 初始化 druid数据库连接池 */ s.
java jdbc 连接池 研究笔记 (自用)
追梦程序员
10-08 208
背景 国庆期间重新开发连接池, 发现曾经设计过的不合理的缺陷代码,早已被删除, 由于当时没有注释说明. 这次又稀里糊涂重新写了一遍, 后来才记起为什么不这么写的原因, 浪费了一些时间,非常懊悔. 另外我觉得底层设计必须多次主动优化,必须要有足够的时间研发,要更加深入理解我们调用的每一个函数,还要进行各种场景的测试.才能确保系统安全 每次优化都有很大收货,对很多东西有了新的理解 记录 网络中断时,...
JDBC的自我学习（自用，自我回顾知识时观看）
weixin_43998127的博客
09-23 111
JDBC学习JDBC1.概述ODBC 也是JDBC的关键所在如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 JDBC 1.概述 JDBC（Java DataBase Connectivity）Java数据库连接（技术），也就是能够通过java代码，连接到数据库，并可以使
myabtis 拉钩高新第一阶段自用
06-04
MyBatis 是由 Paweł Piech 创建的，它是一个基于 Java 的持久层框架，消除了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 使用简单的 XML 或注解进行配置和原始映射，将接口和 Java 的 POJOs(Plain...
自用 ：手动分页
C_S_D_N66的博客
07-31 146
第一步：首先建立一个PageBean package com.qn.jq.daomain; import java.util.List; /** * @author Lizhenye * @date 2019/7/30 20:04 */ public class PageBean<T> { private int totalCount; //总记录数 //需要方...
大数据八股文（自用）
m0_64735594的博客
07-25 1349
实现的逻辑是继承GenericUDF，重写evaluate方法，getdisplay方法。打包上传到hdfs路径上或者hive的lib目录 注册自定义的函数UDTF炸裂 一行多输出 TUDAF聚合多行输出一行Aggregate前台是和用户直接交互的界面和各种实时响应用户请求的业务逻辑。后台是并不直接面向用户的配置管理系统。中台就是各个项目业务中 重复的轮子，比如交易、支付。
Java面试题--自用
jst1999的博客
06-28 326
Java面试题的整理。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 132
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 810
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 865
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 250
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 408
函数式接口与回调函数
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 285
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值