JDBC（MySQL）一周学习总结（一）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JDBC（MySQL）一周学习总结（一），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含17660字，纯文字阅读大概需要26分钟。

内容图文

上面的代码是最基本的连接数据库的实现，但是我们要使用上面的代码去实现连接不同的数据库的时我们就需要去改变源代码中的数据库信息，这样做肯定是不方便，且容易出错的，所以我们接下来实现利用外部配置文件的去实现获取数据库连接

package com.java.jdbc.test;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.Driver;
import java.util.Properties;

import org.junit.Test;

public class TestConnection {
    
//    此方法具有普遍性，在本方法中没有和任何数据库厂商相连接，只需要改变配置文件即可达到连不同的数据库
    public Connection getConnection() throws Exception {
        String driverClass =  null;
        String url = null;
        String user = null;
        String password = null;
        
        InputStream in = getClass().getClassLoader().getResourceAsStream("jdbc.properties");
        
//        通过反射获得配置文件，用 properties 类来获取配置文件的属性
        Properties properties = new Properties();
        properties.load(in);
        driverClass = properties.getProperty("driverClass");
        url = properties.getProperty("url");
        user = properties.getProperty("user");
        password = properties.getProperty("password");

        Driver driver = (Driver) Class.forName(driverClass).newInstance();
        
        Properties info = new Properties();
        info.put("user", user);
        info.put("password", password);
        
        Connection connection = driver.connect(url, info);
        
        return connection;
    }
}

jdbc.properties
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/sh_db
user=root
password=zy961029

DriverManager

管理一组 JDBC 驱动程序的基本服务，可以通过重载的 getConnection() 获取连接更加方便，可以同时管理多个驱动程序，若注册了多个数据库驱动，只需要给 getConnection 方法传入不同的参数即可，下面是利用 DriverManager 获取数据库连接

@Test
    public void getConnection() {
//        通过反射获取配置文件
        InputStream inputStream = getClass().getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        try {
//          获取属性属性值
            properties.load(inputStream);
            String user = properties.getProperty("user");
            String password = properties.getProperty("password");
            String url = properties.getProperty("url");
            String driver = properties.getProperty("driverClass");

//          加载数据库驱动类(注册驱动)
//            注册驱动本应如下注册，但在 com.mysql.Driver 中的静态代码块已经将其注册了，所以不需在写一遍
//            DriverManager.registerDriver(Class.forName(driver).newInstance());
            Class.forName(driver);
            Connection connection = DriverManager.getConnection(url, user, password);
            System.out.printf(String.valueOf(connection));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

 通过上面的介绍我们现在获取到了数据库的连接，那么接下来就是操作数据库（增删改查，首先利用 Statement，使用完毕需要释放）

@Test
    public void testInser() {
//        获取数据库连接
        Connection connection = getConnectionMy();
//        statement 对象是操作 sql 语句的对象
        Statement statement = null;
        try {
//        获取 statement 对象
            statement = connection.createStatement();

            String sql = null;
//            sql = "INSERT INTO book (BOOK_NAME, ISBN, PRICE, STOCK) VALUES (‘SQLServer‘, ‘1004‘, ‘150‘, ‘30‘ )";
//            sql = "DELETE FROM book WHERE id=4";
            sql = "UPDATE book SET PRICE=400 WHERE id=5";
//          执行 sql 语句
            statement.execute(sql);
            System.out.printf("Success");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
//                关闭连接以及 statement
                if (statement != null) {
                    statement.close();
                }

                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

上面的插入操作我们看到其所需要的 sql 语句需要的是完整的，当我们插入的值非常多的时候这样拼写 sql 语句就显得有点不适合，所以我们需要去学习 PrepareStatement，它可以用 ？ 代表插入值，以及更新和删除操作需要传入的参数，同时也需要利用 setXxx 方法去为每一个 ？ 赋值

     @Test
    public void testUpdateWithPrepare() {
        Connection connection;
        PreparedStatement preparedStatement = null;

        connection = JDBCTools.getConnection();

        String sql = "INSERT INTO book (BOOK_NAME, ISBN, PRICE, STOCK) VALUES (?, ?, ?, ?)";

        try {
//            获得 prepareStatement 对象
            preparedStatement = connection.prepareStatement(sql);
//            为每一列赋值，需要传入下标，从 1 开始
            preparedStatement.setString(1, "C#");
            preparedStatement.setString(2, "1008");
            preparedStatement.setString(3, "320");
            preparedStatement.setInt(4, 120);
//             执行更新操作
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.releaseUpdate(preparedStatement, connection);
        }
｝

接下来我们介绍如何进行查的操作，首先需要了解 ResultSet 接口（使用完毕需要释放资源）

ResultSet 封装了 JDBC查询的结果集，并返回一张数据表，并有一个指针指向数据表的第一行，我们调用 next() 方法检测下一行是否有效，若为 true 则下移，我们可以利用 getXxx() 方法获取每一行对应的值

@Test
    public void testSelect() {
        Connection connection = getConnectionMy();
        Statement statement = null;
        String id = null;
        String bookName = null;
        String isbn = null;
//        执行查询操作的对象
        ResultSet resultSet = null;
        String sql = null;

        try {
            sql = "SELECT BOOK_NAME, ISBN, PRICE, STOCK from book WHERE id=5";
//          获取 statement 对象
            statement = connection.createStatement();
//           执行查询操作
            resultSet = statement.executeQuery(sql);

//            处理 resultSet，首先需要判断其是否
            if (resultSet.next()) {
//             获得对应的列的值
                id = resultSet.getString(1);
                bookName = resultSet.getString(2);
                isbn = resultSet.getString(3);
            }

            System.out.printf(id + "; " + bookName + "; " + isbn);
        } 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();
            }
        }
    }

通过上面的方法我们可以体会到每次关闭连接以及以后每次进行相应的操作的时候我们不可能像这样每次都写完整的代码，我们应该像封装获取连接的函数一样去封装其其他方法，写为一个工具类

package jdbc.example.test.myself;

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

public class JDBCTools {

    /*
    * 关闭数据库连接资源
    * */
    public static void release(Statement statement, Connection connection, ResultSet resultSet) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

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

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

    /*
    * 获取数据库连接
    * */
    public static Connection getConnection() {
        String user;
        String password;
        String url;

        Connection connection = null;

        InputStream inputStream = JDBCTools.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        try {
            properties.load(inputStream);

            user = properties.getProperty("user");
            password = properties.getProperty("password");
            url = properties.getProperty("url");

            connection = DriverManager.getConnection(url, user, password);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return connection;
    }

    /*
    * 执行数据库操作，除查询操作
    * */
    public static void update(String sql) {
        Connection connection;
        Statement statement = null;

        connection = getConnection();
        try {
            statement = connection.createStatement();
            statement.executeUpdate(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            releaseUpdate(statement, connection);
        }
    }
}

现在我们的工具类中并没有通用的查询方法，为了完善我们的工具类我们需要学习 JavaBean 和 ResultSetMetaData

JavaBean 其实就是普通的 java 类，不同的是没有 main 方法，只包含变量和对应的 set、get 方法，数据表对应的类就需要用 JavaBean 去写，其变量名对应数据表的列名，若列名为两个单词那么对应的变量名的第二个单词需大写，如：book_name --> bookName，isbn --> isbn

ResultSetMetaData 是描述 ResultSet 元数据的接口，它可以获取到结果集有多少列，以及列名和列的别名

我们都已经知道 ResultSet 返回的是一张数据表，如果我们还像以前那样在方法中为每一列新建一个变量，就不能完成通用的查询方法，所以我们需要为每张数据表创建一个对应的类，用 JavaBean 的规则。这样 ResultSet 结果集的每一行对应一个对象。

在方法中我们可以利用 ResultSetMetaData 获得结果集中列的别名，以及从结果集中获得对应的值，我们将其存为一个键位列名，值为列值的键值对，方便后面为数据表对应的对象赋值以便打印。

注意：在测试方法中书写 SQL 语句的时候，我们应该向 javaBean 看齐，也就是如果数据表对应的列名为两个单词，那么就应该为其起一个别名，和 JavaBean 对应的变量名统一，如果没有统一，将打印 null！

//   通用的查询方法，clazz 为数据表对应的类
    public <T> T get(Class<T> clazz, String sql, Object ... args) {
        T entity = null;

        Connection connection;
        PreparedStatement preparedStatement;
        ResultSet resultSet;
        ResultSetMetaData resultSetMetaData;
//        存储列名以及列值
        Map<String, Object> map = new HashMap<String, Object>();

        connection = JDBCTools.getConnection();
        try {
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(1, args[i]);
            }
            resultSet = preparedStatement.executeQuery();
            resultSetMetaData = resultSet.getMetaData();

            if (resultSet.next()) {
                for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
                    map.put(resultSetMetaData.getColumnLabel(i), resultSet.getObject(i));
                }
            }

//            判断 map 中是否有值，若有则利用反射创建对象，并为之赋值
            if (map.size() > 0) {
                entity = clazz.newInstance();
//                利用for 循环为每一个变量赋值
                for (Map.Entry<String, Object> entry: map.entrySet()) {
                    String fieldName = entry.getKey();
                    Object fieldValue = entry.getValue();

                    Field field = clazz.getDeclaredField(fieldName);
//                    打破封装
                    field.setAccessible(true);
                    field.set(entity, fieldValue);
                }
            }

            System.out.printf(String.valueOf(entity));
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }

        return entity;
    }
    @Test
    public void testSelect() {
        String sql = "SELECT id, BOOK_NAME bookName, isbn, price, stock FROM book WHERE id = ?";
//        testSelect(SH_DB.class, sql, 5);
        get(SH_DB.class, sql, 6);
    }

package com.jdbc.dao.my.first.test;

/**
 * Created by shkstart on 2017/10/31.
 */
public class SH_DB {
    private String bookName;
    private String isbn;
    private int price;
    private int stock;

    public SH_DB() {
    }

    public SH_DB(String bookName, String isbn, int price, int stock) {
        this.bookName = bookName;
        this.isbn = isbn;
        this.price = price;
        this.stock = stock;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }
//   为了方便打印重写 toString 方法
    @Override
    public String toString() {
        return "SH_DB{" +
                "bookName=‘" + bookName + ‘\‘‘ +
                ", isbn=‘" + isbn + ‘\‘‘ +
                ", price=" + price +
                ", stock=" + stock +
                ‘}‘;
    }
}

 上面我们利用反射的方式对数据表对象进行了赋值操作，我们还可以利用一个 beanUtils 工具类为其赋值   BeanUtils.setProperty(class, fieldName, fieldValue); 

现在我们可以将工具类方法进行完善以及将其进行重构，包括了查询多条记录，查询单条记录，查询单个值，更新等操作，如下：

package com.jdbc.dao.my.first.test;

import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.sql.*;
import java.util.*;

/**
 * Created by shkstart on 2017/10/31.
 */

/*
* Dao -> Data Access Object
* 包括了对数据库 CRUD (Create read update delete) 操作，而不包含任何业务逻辑信息
* 可以实现功能模块化，便于维护
* */
public class DaoOfMy {

    //    更新数据库的方法，可能是删除，更新，增加操作
    public void update(String sql, Object... args) {
        Connection connection;
        PreparedStatement preparedStatement = null;

        connection = JDBCTools.getConnection();
        try {
            preparedStatement = connection.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }

            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.releaseConnection(connection, preparedStatement, null);
        }
    }

    //    查询一条记录
    public <T> T get(Class<T> clazz, String sql, Object... args) {
        T entity = null;

        Connection connection;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        ResultSetMetaData resultSetMetaData = null;
        Map<String, Object> map = new HashMap<String, Object>();

        connection = JDBCTools.getConnection();
        try {
            preparedStatement = connection.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }

            resultSet = preparedStatement.executeQuery();
            resultSetMetaData = resultSet.getMetaData();

            if (resultSet.next()) {
                for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {
                    String colLabel = resultSetMetaData.getColumnLabel(i + 1);
                    Object colVal = resultSet.getObject(i + 1);
                    map.put(colLabel, colVal);
                }
            }

            if (map.size() > 0) {
                entity = clazz.newInstance();
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    String fieldName = entry.getKey();
                    Object fieldVal = entry.getValue();
                    setFieldVal(entity, fieldName, fieldVal);
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.releaseConnection(connection, preparedStatement, resultSet);
        }

        return entity;
    }
//查询多条记录
    public <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
//       存取所有对象
        List<T> entities = new ArrayList<T>();

        Connection connection;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        connection = JDBCTools.getConnection();
        try {
            preparedStatement = connection.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }

            resultSet = preparedStatement.executeQuery();

//        存取查询到的多条记录
            List<Map<String, Object>> listMap = handleResultSetToMapList(resultSet);
//        存取对象集合
            entities = changeMapListToBeanList(clazz, listMap);

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.releaseConnection(connection, preparedStatement, resultSet);
        }

        return entities;
    }

    private <T> List<T> changeMapListToBeanList(Class<T> clazz, List<Map<String, Object>> listMap) throws InstantiationException, IllegalAccessException {

        List<T> entities = new ArrayList<T>();
        T entity2;
        if (listMap.size() > 0) {

            Iterator<Map<String, Object>> iterator = listMap.iterator();

            while (iterator.hasNext()) {
                entity2 = clazz.newInstance();
                for (Map.Entry<String, Object> entry : iterator.next().entrySet()) {
                    String fieldName = entry.getKey();
                    Object fieldVal = entry.getValue();
                    setFieldVal(entity2, fieldName, fieldVal);
                }
                entities.add(entity2);
            }
        }
        return entities;
    }

//    处理结果集，将查询到的每一条结果集存入到 List 中
    private List<Map<String, Object>> handleResultSetToMapList(ResultSet resultSet) throws SQLException {

        List<Map<String, Object>> mapList = new ArrayList<Map<String, Object>>();
        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
//        存取查询结果中的一条记录
        Map<String, Object> map;
        while (resultSet.next()) {
//                每次都将 map 对象 new 一下，这样每次就是不同的值，不会出现一直存取第一个值
            map = new HashMap<String, Object>();
            for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {
                String colLabel = resultSetMetaData.getColumnLabel(i + 1);
                Object colVal = resultSet.getObject(i + 1);
                map.put(colLabel, colVal);
            }
            mapList.add(map);
        }
        return mapList;
    }

    public void setFieldVal(Object obj, String fieldName, Object fieldVal) {
//        Field field;
        try {
//            使用反射赋值
//            field = obj.getClass().getDeclaredField(fieldName);
//            field.setAccessible(true);
//            field.set(obj, fieldVal);
//            使用 BeanUtils 操作类的属性
            BeanUtils.setProperty(obj, fieldName, fieldVal);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    // 获取单个值
    public int getForValue(String sql) {
        Connection connection;
        int count = 0;
        PreparedStatement preparedStatement;
        ResultSet resultSet;

        connection = JDBCTools.getConnection();
        try {
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();

            if (resultSet.next()) {
                count = resultSet.getInt(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }
}

 以上是上一周学习的一部分，剩下的我很快就会发布，希望大家提出自己宝贵的意见，谢谢！

JDBC（MySQL）一周学习总结（一）

标签：ons   use   如何   体会   test   get   exception   column   root   

本文系统来源：http://www.cnblogs.com/bgzyy/p/7790075.html

内容总结

以上是互联网集市为您收集整理的JDBC（MySQL）一周学习总结（一）全部内容，希望文章能够帮你解决JDBC（MySQL）一周学习总结（一）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端