Java如何连接数据库及基本操作 超详细

Posted 2021-09-07 好好学好好看

如果你没有mysql基础，请查看我的另一篇文章：

MySQL知识扫盲

先导入jar包；

查看是否成功了。

如果没出现这个，说明没有导入成功。这要操作：

总之你得找到这个jar包，后续步骤可以点ok就可以了。如果没有数据库表，那我们可以创建，你可以使用我这个数据：

CREATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
);

插入数据：

INSERT INTO `user` VALUES (\'1\', \'aaa\', \'222\');
INSERT INTO `user` VALUES (\'2\', \'liuzhiwei\', \'12222\');
INSERT INTO `user` VALUES (\'3\', \'hah123\', \'321\');
INSERT INTO `user` VALUES (\'4\', \'hba\', \'3213\');
INSERT INTO `user` VALUES (\'5\', \'lucy\', \'321\');
INSERT INTO `user` VALUES (\'6\', \'tom\', \'123\');
INSERT INTO `user` VALUES (\'7\', \'唐佳帅\', \'123321\');
INSERT INTO `user` VALUES (\'8\', \'如花\', \'222\');
INSERT INTO `user` VALUES (\'9\', \'二哈\', \'999\');
INSERT INTO `user` VALUES (\'11\', \'小强2\', \'3213\');
INSERT INTO `user` VALUES (\'12\', \'我是刘志伟\', \'234\');
INSERT INTO `user` VALUES (\'13\', \'我是刘志伟一号\', \'234\');
INSERT INTO `user` VALUES (\'14\', \'我是刘志伟二号\', \'345\');
INSERT INTO `user` VALUES (\'15\', \'我是刘志伟三号号\', \'345\');
INSERT INTO `user` VALUES (\'16\', \'321\', \'321\');
INSERT INTO `user` VALUES (\'17\', \'靳三\', \'333\');
INSERT INTO `user` VALUES (\'37\', \'www\', \'000\');

哦对了，数据库名字记得修改哈，我这给出的是一张表，不是数据库。

全代码来啦：

------------------------分页查询------------------------

package com.tjetc;

import java.sql.*;

/**
 * jdbc操作数据库
 */
public class JdbcDemo1 {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        queryLimit();
    }

    /**
     * 分页查询数据
     */
    private static void queryLimit() throws ClassNotFoundException, SQLException {
        // 1.加载驱动（Mysql）
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接 ：//主机：端口/数据库名称?参数key=value&key1=value1
        String url = "jdbc:mysql://localhost:3306/stu?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai";
        //登录mysql账号
        String mysqlUsername = "root";
        //获取密码
        String mysqlPassword = "123456";
        Connection conn = DriverManager.getConnection(url, mysqlUsername, mysqlPassword);
        //3.获取PrepareStatement对象，sql语句中 问号 表示参数占位符
        String sql = "select id,`username`,`password` from `user` ORDER BY id ASC LIMIT ?,?";
        PreparedStatement ps = conn.prepareStatement(sql);
        //设置具体的参数值，替换问号的参数占位符；
        //参数1，表示参数索引从1开始，sql语句从左边开始数起 问号的位置索引值 参数2：表示替换问号的具体参数值
        ps.setObject(1, 0);
        ps.setObject(2, 3);
        //4.执行sql.处理结果
        //查询使用executeQuery()方法
        ResultSet rs = ps.executeQuery();
        //rs.next()游标移动，返回是否有数据true表示有数据false表示没有数据
        rs.next();
        while (rs.next()) {
            //rs.getObject()获取每列的值，列起算1开始
            Object id = (Long) rs.getObject(1);
            String username = (String) rs.getObject(2);
            String password = (String) rs.getObject(3);
            System.out.println(id + "," + username + "," + password);
        }
        //5.关闭资源（属顺序有要求，先实例化后关闭，后实例化先关闭）
        rs.close();
        ps.close();
        conn.close();
    }
}

 

 

跑一跑代码试试：

------------------------更新------------------------

package com.tjetc;

import java.sql.*;

/**
 * jdbc操作数据库
 */
public class JdbcDemo1 {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        //queryLimit();
        update();//更新
    }

    private static void update() throws ClassNotFoundException, SQLException {
        // 1.加载驱动（Mysql）
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接 ：//主机：端口/数据库名称?参数key=value&key1=value1
        String url = "jdbc:mysql://localhost:3306/stu?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai";
        //登录mysql账号
        String mysqlUsername = "root";
        //获取密码
        String mysqlPassword = "123456";
        Connection conn = DriverManager.getConnection(url, mysqlUsername, mysqlPassword);
        //3.获取PrepareStatement对象，sql语句中 问号 表示参数占位符
        String sql = "update user set Username=?,password=? where id=?";
        PreparedStatement ps = conn.prepareStatement(sql);
        //设置具体的参数值，替换问号的参数占位符；
        //参数1，表示参数索引从1开始，sql语句从左边开始数起 问号的位置索引值 参数2：表示替换问号的具体参数值
        ps.setObject(1, "kkk");
        ps.setObject(2, "777");
        ps.setObject(3, 1);
        //4.执行sql.处理结果
        //查询使用executeQuery()方法
        int i = ps.executeUpdate();
        if (i > 0) {
            System.out.println("更新成功");
        } else {
            System.out.println("更新失败");
        }
        //5.关闭资源（属顺序有要求，先实例化后关闭，后实例化先关闭）
        ps.close();
        conn.close();
    }
}

 

 

其实只需要做一部分改动就可以了。先创建方法名；

update();

idea会给你创建方法的。然后把之前的代码粘贴进来，进行修改部分代码（更新的代码）；

为什么i>0就说明更新成功了？

请看一下信息你就懂啦。

------------------------------删除------------------------------

private static void delete() throws ClassNotFoundException, SQLException {
        // 1.加载驱动（Mysql）
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接 ：//主机：端口/数据库名称?参数key=value&key1=value1
        String url = "jdbc:mysql://localhost:3306/stu?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai";
        //登录mysql账号
        String mysqlUsername = "root";
        //获取密码
        String mysqlPassword = "123456";
        Connection conn = DriverManager.getConnection(url, mysqlUsername, mysqlPassword);
        //3.获取PrepareStatement对象，sql语句中 问号 表示参数占位符
        String sql = "delete from user where id=?";
        PreparedStatement ps = conn.prepareStatement(sql);
        //设置具体的参数值，替换问号的参数占位符；
        //参数1，表示参数索引从1开始，sql语句从左边开始数起 问号的位置索引值 参数2：表示替换问号的具体参数值
        ps.setObject(1, 2);
        //4.执行sql.处理结果
        //查询使用executeQuery()方法
        int i = ps.executeUpdate();
        if (i > 0) {
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败");
        }
        //5.关闭资源（属顺序有要求，先实例化后关闭，后实例化先关闭）
        ps.close();
        conn.close();
    }

------------------------------插入------------------------------

private static void insert() throws ClassNotFoundException, SQLException {
        // 1.加载驱动（Mysql）
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接 ：//主机：端口/数据库名称?参数key=value&key1=value1
        String url = "jdbc:mysql://localhost:3306/stu?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai";
        //登录mysql账号
        String mysqlUsername = "root";
        //获取密码
        String mysqlPassword = "123456";
        Connection conn = DriverManager.getConnection(url, mysqlUsername, mysqlPassword);
        //3.获取PrepareStatement对象，sql语句中 问号 表示参数占位符
        String sql = "insert into user(username,password) values(?,?)";
        //Statement.RETURN_GENERATED_KEYS返回自增主键
        PreparedStatement ps=conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);
        //设置具体的参数值，替换问号的参数占位符；
        //参数1，表示参数索引从1开始，sql语句从左边开始数起 问号的位置索引值 参数2：表示替换问号的具体参数值
        ps.setObject(1, "lisi");//插入名字
        ps.setObject(2, "222");//插入密码222
        //4.执行sql.处理结果
        //查询使用executeQuery()方法
        ps.executeUpdate();
        //获取自增主键
        ResultSet rs = ps.getGeneratedKeys();
        if(rs.next()){
            //获取自增的主键值
            BigInteger bId=(BigInteger) rs.getObject(1);
            //转化成Long类型
            Long id=bId.longValue();
            //打印自增主键值
            System.out.println("自增主键为："+id);
        }
        //5.关闭资源（属顺序有要求，先实例化后关闭，后实例化先关闭）
        rs.close();
        ps.close();
        conn.close();
    }

自此，我们完成了数据库的增删改查！但是代码重复太多了。有没有更好的办法呢？老师给封装的代码如下：

先配置创建文件：

在原来的包下创建一个包，导入封装好的类。因为类在电脑里，我直接导入了。或者源代码如下：

package com.tjetc.common;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.*;

public class DBUtil {
    private static String driverName;
    private static String url;
    private static String username;
    private static String password;

    static {
        InputStream inputStream = null;
        try {
            //创建db.properties的流
            inputStream = DBUtil.class.getClassLoader().getResourceAsStream("db.properties");
            //创建Properties对象
            Properties p = new Properties();
            //把数据流读入Properties对象中
            p.load(inputStream);
            //从Properties对象中获取配置数据
            url = p.getProperty("url");
            username = p.getProperty("username");
            password = p.getProperty("password");
            driverName = p.getProperty("driverName");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * insert语句使用，返回新增数据的自增主键。
     *
     * @param sql
     * @return
     */
    public static Object insert(Connection connection, String sql, Object[] params) throws SQLException {
        PreparedStatement ps = null;
        Object id = null;
        try {
            //创建PreparedStatement
            ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            //设置参数
            setPreparedStatementParam(ps, params);
            //执行sql
            ps.executeUpdate();
            // 执行此 Statement 对象而创建的所有自动生成的键
            ResultSet rs = ps.getGeneratedKeys();
            if (rs.next()) {
                // 指定返回生成的主键
                id = rs.getObject(1);
            }
        } finally {
            close(ps);
        }
        return id;
    }

    /**
     * insert语句使用，返回新增数据的自增主键。
     *
     * @param sql
     * @return
     */
    public static Object insert(String sql, Object[] params) throws SQLException, ClassNotFoundException {
        Connection conn = null;
        Object id;
        try {
            //创建连接
            conn = getConnection();
            id = insert(conn, sql, params);
        } finally {
            close(conn);
        }
        return id;
    }

    /**
     * 更新、删除
     *
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static boolean update(Connection connection, String sql, Object[] params) throws SQLException {
        PreparedStatement ps = null;
        try {
            //步骤2：设置SQL语句以及对应的参数
            ps = connection.prepareStatement(sql);
            setPreparedStatementParam(ps, params);
            //步骤3：执行update
            int result = ps.executeUpdate();
            //返回执行的结果
            return result > 0 ? true : false;
        } finally {
            //步骤4：关闭资源
            close(ps);
        }
    }

    /**
     * 更新、删除
     *
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static boolean update(String sql, Object[] params) throws SQLException, ClassNotFoundException {
        Connection connection = null;
        try {
            //步骤1：获取链接
            connection = getConnection();
            return update(connection, sql, params);
        } finally {
            //步骤2：关闭连接资源
            close(connection);
        }
    }

    /**
     * 查询一个
     *
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static Map<String, Object> selectOne(Connection connection, String sql, Object[] params) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            //步骤2：设置SQL语句以及对应的参数
            ps = connection.prepareStatement(sql);
            setPreparedStatementParam(ps, params);

            //步骤3：执行查询，把查询结果的列作为key，列对应的值作为value，保存到Map中
            rs = ps.executeQuery();

            if (rs.next()) {
                return getResultMap(rs);
            }
        } finally {
            //步骤4：关闭资源
            close(rs, ps);
        }
        return null;
    }

    /**
     * 获取ResultMap
     *
     * @param rs
     * @return
     * @throws SQLException
     */
    private static Map<String, Object> getResultMap(ResultSet rs) throws SQLException {
        //获取到result的元数据，包含了列的信息
        ResultSetMetaData metaData = rs.getMetaData();

        //获取到当前表的所有的列的列数
        int columnCount = metaData.getColumnCount();

        //存储数据库列与值的map
        Map<String, Object> map = new HashMap<>();

        //根据列的数量，获取到每一个列的列名以及对应的值
        for (int i = 0; i < columnCount; i++) {
            //能够获取到每一个列的名称，参数是每个列的序号值
            String columnLabel = metaData.getColumnLabel(i + 1);
            Object columnValue = rs.getObject(columnLabel);
            map.put(columnLabel, columnValue);

        }
        return map;
    }

    /**
     * 查询一个
     *
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static Map<String, Object> selectOne(String sql, Object[] params) throws SQLException, ClassNotFoundException {
        Connection connection = null;
        try {
            //步骤1：获取链接
            connection = getConnection();
            return selectOne(connection, sql, params);
        } finally {
            //步骤4：关闭资源
            close(connection);
        }
    }

    /**
     * 查询集合
     *
     * @param sql
     * @param params
     * @return
     */
    public static List<Map<String, Object>> selectList(Connection connection, String sql, Object[] params) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<Map<String, Object>> list;
        try {
            //步骤2：设置SQL语句以及对应的参数
            ps = connection.prepareStatement(sql);
            setPreparedStatementParam(ps, params);

            //步骤3：执行查询，把查询结果的列作为key，列对应的值作为value，保存到Map中
            rs = ps.executeQuery();
            list = new ArrayList<>();

            while (rs.next()) {
                list.add(getResultMap(rs));
            }
        } finally {
            //步骤4：关闭资源
            close(rs, ps);
        }
        return list;
    }

    /**
     * 查询集合
     *
     * @param sql
     * @param params
     * @return
     */
    public static List<Map<String, Object>> selectList(String sql, Object[] params) throws SQLException, ClassNotFoundException {
        Connection connection = null;
        try {
            connection = getConnection();
            return selectList(connection, sql, params);
        } finally {
            close(connection);
        }
    }

    /**
     * 设置参数
     *
     * @param ps
     * @param params
     * @throws SQLException
     */
    private static void setPreparedStatementParam(PreparedStatement ps, Object[] params) throws SQLException {
        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
        }
    }

    /**
     * 获取连接
     *
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws ClassNotFoundException, SQLException {
        //加载数据库驱动
        Class.forName(driverName);
        return DriverManager.getConnection(url, username, password);
    }

    //开启事务
    public static void begin(Connection conn) throws SQLException {
        conn.setAutoCommit(false);
    }

    //提交事务
    public static void commit(Connection conn) throws SQLException {
        conn.commit();
    }

    //回滚事务
    public static void rollback(Connection conn) throws SQLException {
        conn.rollback();
    }

    public static void close(Connection connection) {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 释放ResultSet,PreparedStatement
     */
    private static void close(ResultSet rs, PreparedStatement ps) {
        close(rs);
        close(ps);
    }

    private static void close(PreparedStatement statement) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    private static void close(ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

 

现在我们创建一个类：JdbcDemo2

创建两个方法：

queryLimit();//查询
update();//更新

idea会给你创建对应的方法；

-------------------------------------update-----------------------------

update方法的代码：

public static void update() throws SQLException, ClassNotFoundException {
        String sql="update user set username=?,password=? where id=?";
        Object[]params={"mm","0000",3};
        //更新或删除
    boolean bl=DBUtil.update(sql,params);
    if(bl){
        System.out.println("更新成功");
    }
    else{
        System.out.println("更新失败");
    }
}

queryLimit 方法代码：

 private static void queryLimit() throws SQLException, ClassNotFoundException {
        //sql语句，查询结果password 使用了别名
        String sql="select id,username,password p from user order by id asc limit ?,?";
        //Object []params =new Object []{0,3};
        //简写方式 实例化数组 并初始化 参数
        Object[] params={0,3};
        //查询多条数据
        List<Map<String,Object>>maps=DBUtil.selectList(sql,params);
        for(Map<String,Object>map:maps){
            //id值
            Long id=(Long) map.get("id");
            //用户名
            String username=(String) map.get("username");
            //密码
            String p=(String) map.get("p");
            //打印
            System.out.println(id+","+username+","+p);
        }
    }

insert()方法代码：

private static void insert() throws SQLException, ClassNotFoundException {
        String sql="insert into user(username,password) values(?,?)";
        Object[]params={"qq","123"};//
        //返回自增主键
        BigInteger bId=(BigInteger) DBUtil.insert(sql,params);
        //id
        Long id=bId.longValue();
        //打印
        System.out.println("自增主键为："+id);
    }

 

delete（）方法

    private static void delete() throws SQLException, ClassNotFoundException {
        String sql="delete from user where id=?";
        Object[]params= {40};
        boolean i =  DBUtil.update(sql,params);
        if(i){
            System.out.println("删除成功");
        }
        else{
            System.out.println("删除失败");
        }
    }