MySql数据库再学习——使用强化版的自定义连接池连接数据库

一：两个重点，

一是获取properties文件的路径，总结在注释里，我当时获取了好半天，总是找不到文件。

二是理清这几个class之间的联系，以及本次demo的思路逻辑关系：总的来说就是，在原有的driverManager获取的基础上——>创建一个池子（池子中存储若干个基础的Connection对象）

——>书写一个强化类实现Connection接口（强化的是close（）方法）——>在主程序中调用的时候 调用的是从池子中取出来的，强化后的 Connection对象。

dbUtil.class

public class dbUtil {

    /*初始化需要用到的变量*/
    private static Connection conn;
    private static PreparedStatement pst;
    private static ResultSet rs;

    private static String driver;
    private static String url;
    private static String username;
    private static String password;
    private static InputStream in;
    private static ClassLoader cl;

    static {
        try {
            //获取当前类的类加载器
            //cl = Thread.currentThread().getContextClassLoader();

            //获取配置文件的输入流
            // in = cl.getResourceAsStream("db.properties");

            //切忌使用中文命名文件夹，否则dbUtil.class.getResource("/db.properties").getFile()会找不到文件路径
            FileInputStream in = new FileInputStream(dbUtil.class.getResource("/db.properties").getFile());

            //创建一个properties文件对象
            Properties ppt = new Properties();
            //加载输入流
            ppt.load(in);
            //获得相关参数
            driver = ppt.getProperty("driver");
            url = ppt.getProperty("url");
            username = ppt.getProperty("username");
            password = ppt.getProperty("password");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private MyDbConnection conn1;


    public static Connection getConnection() throws ClassNotFoundException, SQLException {
        //注册驱动
        Class.forName(driver);
        //连接数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        return connection;
    }


    public static void release(MyDbConnection conn, PreparedStatement pst, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (pst != null) {
            try {
                pst.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test() {


        String sql = "select * from test where name=?";
        LinkPool pool = new LinkPool();
        for (int i=0;i<25;i++){
            try {
                //conn=getConnection();
                //这个链接是从池子里取的，此时尺子中的连接是强化过得 战斗力翻倍.:)
                conn1 = (MyDbConnection) pool.getConnection();
                System.out.println(conn1.getClass());
                //这个prepareStatement方法也是重写过得 否则重写过的conn是得不到该方法的
                pst = conn1.prepareStatement(sql);
                pst.setString(1, "张浩");
                rs = pst.executeQuery();
                while (rs.next()) {
                    System.out.println(rs.getString("name"));
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //release对象中的close方法也是重写过的
                release(conn1, pst, rs);
            }
        }

    }

}

LinkPool.class

public class LinkPool implements DataSource {
        //定义一个池子对象

    private static LinkedList<Connection> pool = new LinkedList<>();
    public  LinkPool(){

            for (int i = 0; i < 5; i++) {
                try {
                    pool.add(new MyDbConnection(dbUtil.getConnection(), pool));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("池子中的个数为： "+pool.size());
        }





    @Override
    public Connection getConnection() throws SQLException {

        System.out.println("当前pool: "+pool.size());
        if (pool.size() == 0) {
            for (int i = 0; i < 5; i++) {
                try {
                    //想池子中添加Myconnection对象
                    pool.add(new MyDbConnection( dbUtil.getConnection(), pool));

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
      /* Connection  conn=(MyDbConnection)pool.remove(0);*/
        //System.out.println("当前pool1: "+pool.size());
        return  new MyDbConnection(pool.remove(0),pool);
    }}

MyDbConnection.class

public class MyDbConnection implements Connection {
    //为了通过构造方法 将普通的connection对象传进来，然后对close方法进行强化
    //pool对象也是如此
    private Connection conn;
    private LinkedList<Connection> pool;

    public MyDbConnection(Connection conn, LinkedList<Connection> pool) {
        this.conn = conn;
        this.pool = pool;
    }

    @Override
    public void close() throws SQLException {
        System.out.println("对象归还");
        //实现pool的对象补充
        pool.add(conn);
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        //重写prepareStatement方法
        return conn.prepareStatement(sql);
    }

}