web 学习笔记16-JDBC连接池扩展已知类

最新推荐文章于 2021-11-17 14:08:13 发布

pin-csdn

最新推荐文章于 2021-11-17 14:08:13 发布

阅读量573

点赞数

分类专栏： Web

本文链接：https://blog.csdn.net/gaopinqiang/article/details/76039711

版权

Web 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1、连接池：

为什么要用连接池，如果你的服务器servlet有个添加数据的方法，里面需要获取一个数据库连接，如果有100000个人同时访问
那么你就需要创建10000个连接，而且连接是个很耗时的操作，也会浪费内存，导致服务器内存溢出。

模拟下连接池，就类似一个池子，提前放好一些连接，需要的时候直接拿来用。
例如：mysql的jar包需要先导入。

a.一个数据库的工具类

        public class JdbcUtils {
            private static String driverClass = "" ;
            private static String url = "" ;
            private static String user = "" ;
            private static String password  = "";
            static{
                ResourceBundle rb = ResourceBundle.getBundle("dbcfg") ;
                driverClass = rb.getString("driverClass") ;
                url = rb.getString("url") ;
                user = rb.getString("user") ;
                password = rb.getString("password") ;
                try {
                    Class.forName(driverClass) ;
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
            public static Connection getConnection(){
                try {
                    return DriverManager.getConnection(url, user, password) ;
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                return null ;
            }
            public static void release(ResultSet rs ,Statement stmt,Connection conn){
                if(rs != null){
                    try {
                        rs.close() ;
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                if(stmt != null){
                    try {
                        stmt.close() ;
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if(conn != null){
                    try {
                        conn.close() ;
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

b.模拟创建一个连接池

        public class MyConnectionPool1 {
            //增删方便
            private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
            static{
                for (int i = 0; i < 10; i++) {
                    Connection conn = JdbcUtils.getConnection() ;
                    pool.add(conn) ;
                }
            }
            public synchronized static Connection getConnection(){
                if(pool.size() > 0)
                    return pool.removeFirst() ;
                else
                    throw new RuntimeException("对不起，服务器忙") ;
            }
            public static void close(Connection conn){
                if(conn != null)
                    pool.addLast(conn) ;   //放回池中   
            }
        }

c.模拟连接池的原理(dao层的实现类)

        public class DaoImpl {
            @Test
            public void add(){
                //拿到连接
                Connection conn = null ;
                PreparedStatement pstmt = null ;
                try {
                    conn = MyConnectionPool1.getConnection() ;   // 左边； 抽象层   右边： 真实的对象 com.mysql.jdbc.Connecotion
                    pstmt = conn.prepareStatement("") ;
                    //.......
                } catch (Exception e) {
                    e.printStackTrace() ;
                }finally{
                    JdbcUtils.release(null, pstmt, null) ;
                    MyConnectionPool1.close(conn) ;
                }
            }
        }

2、我们实际开发中一般使用数据源 DataSource：

底层也是连接池，我们创建一个类，实现DataSource接口
例如

        public class MyDataDource2 implements DataSource{
            private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
            static{//写一个静态块，默认放10个连接
                for (int i = 0; i < 10; i++) {
                    Connection conn = JdbcUtils.getConnection() ;
                    pool.add(conn) ;
                }
            }

            @Override
            public Connection getConnection() throws SQLException {
                if(pool.size() > 0 ){
                     return pool.removeFirst() ;  //右边： com.mysql.jdbc.Connection
                }else
                    throw new RuntimeException("对不起,服务器忙") ;
            }

            //未实现的一些方法
        }

    我们的dao实现类：

        public class DaoImpl {
            private  DataSource ds ;
            public DaoImpl(DataSource ds) {//我们将数据源通过构造函数传进来
                this.ds = ds ;
            }
            @Test
            public void add(){
                DataSource ds = new MyDataDource2()  ; ;
                //拿到连接
                Connection conn = null ;
                PreparedStatement pstmt = null ;
                try {
                    conn = ds.getConnection() ;   //通过数据源去拿取连接
                    pstmt = conn.prepareStatement("") ;
                    //.......
                } catch (Exception e) {
                    e.printStackTrace() ;
                }finally{
                    if(pstmt != null){
                        try {
                            pstmt.close() ;
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
                    if(conn != null){
                        try {
                            conn.close() ;    //不能关，这个是调用真实mysql连接对象的close方法
                                               //一定要还回池中,此时需要改写close方法.
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

我们现在遇到的一个问题就是：我们拿到了conn，但是不能关（关了连接池的意义就没了），又不能放回池中。
    我的人想在MyDataDource2类中添加一个close方法，然后调用，实际是不行的（conn是一个接口，怎么可能调用它实现类的方法呢）

3、扩展已知类功能-包装类：

通常3种方法：
    子类
    包装类（装饰模式、适配器模式）
    动态代理

上面有个不能调用close方法关闭连接，有放回不到池中，我们就想办法扩展mysql的Connect类的功能
然close方法不是关闭连接，而是将连接放回池中。

如何扩展已知类的功能（不能修改源码）
a.子类
    继承父类
    不好，不用，与具体的类相关
b.包装类（装饰模式）
    步骤
    1. 写一个类，实现和被包装类相同的接口 (使他们具有相同的行为)
    2. 创建一个实例变量，引用被包装类对象 (最好做到与具体类无关)
    3. 编写一个构造函数，传入被包装类对象 (注入： DI)
    4. 对于需要改写的方法，写自己的代码
    5. 对于不需要改写的方法，引用被包装类的对象的对应方法即可

    例如：

        创建个包装类
        public class MyConnection3 implements Connection{//步骤1
            private Connection conn ;//步骤2，这个是java.sql接口，mysql里面的Connect也实现了这个接口
            private LinkedList<Connection> pool ;

            //注意，这个形参的conn就是你传进来的mysql的真实对象。如果你传的oracle的conn，就包装oracle
            public MyConnection3(Connection conn,LinkedList<Connection> pool){//步骤3
                this.conn = conn ;
                this.pool = pool ;
            }

            @Override
            public PreparedStatement prepareStatement(String sql) throws SQLException {
                return conn.prepareStatement(sql);//步骤5,默认使用mysql的prepareStatement方法
            }

            @Override
            public void close() throws SQLException {//步骤4
                //需要将连接还回池中
                pool.addLast(conn) ;
            }
            //------------下面是默认实现的接口，省略,
        }

    改写下数据源类

        public class MyDataDource2 implements DataSource{
            private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
            static{//写一个静态块，默认放10个连接
                for (int i = 0; i < 10; i++) {
                    Connection conn = JdbcUtils.getConnection() ;
                    pool.add(conn) ;
                }
            }

            @Override
            public Connection getConnection() throws SQLException {
                if(pool.size() > 0 ){
                     Connection conn =  pool.removeFirst() ;  //右边： com.mysql.jdbc.Connection
                    MyConnection3 mconn = new MyConnection3(conn,pool);//这里我们使用了自己改写的包装类，可以调用自己的close
                    return mconn;
                }else
                    throw new RuntimeException("对不起,服务器忙") ;
            }

            //未实现的一些方法
        }

    我们的dao实现类不需要改，直接可以调用close方法了，就把conn放回到池子中了。

    注意：关键地方就是我们创建了一个自己的类MyConnection3，替代了mysql里面的Connection类的功能。
        我们定义的类可以自定义，功能也可以更多。

c.适配器模式：
    和包装类似，只不过这个将适配器类单独写出来，我们再写一个类继承适配器类。
    创建一个适配器类：
    步骤：
        1. 写一个类，实现和被包装类相同的接口 (使他们具有相同的行为)
        2. 创建一个实例变量，引用被包装类对象 (最好做到与具体类无关)
        3. 编写一个构造函数，传入被包装类对象 (注入： DI)
        4. 对所有的方法方法，引用被包装类的对象的对应方法即可

            public class MyConenctionAdapter implements Connection {
                private Connection conn ;
                public MyConenctionAdapter(Connection conn) {
                    this.conn = conn ;
                }

                @Override
                public PreparedStatement prepareStatement(String sql) throws SQLException {
                    return conn.prepareStatement(sql);
                }
                //----以下所有的方法都调用mysql connect类里面的方法
            }

    创建一个我们自己的类，继承这个适配器类，然后重写下close方法：
    步骤：
        1. 写一个类，继承适配器类 (使他们具有相同的行为)
        2. 创建一个实例变量，引用被包装类对象 (最好做到与具体类无关)
        3. 编写一个构造函数，传入被包装类对象 (注入： DI)
        4. 对需要改写的方法重写代码即可

            public class MyConnection extends MyConenctionAdapter {
                private Connection conn ;
                private LinkedList<Connection> pool ;
                public MyConnection(Connection conn,LinkedList<Connection> pool) {
                    super(conn) ;
                    this.pool = pool ;
                    this.conn = conn;
                }

                @Override
                public void close() throws SQLException {
                    pool.add(conn) ;//重写close方法，将连接放回池中
                }
            }

上面2种方式类似，都是通过实现了你要扩展类的相同接口。
    包装类是直接实现接口的时候就把close方法重写了
    适配器模式就是你继承的时候再重写close方法。

4、扩展已知类功能-静态代理

实际中不用
简单的代码演示下：
a.有个Person类：

        public class Person {
            public void eat() {
                System.out.println("吃饭");
            }
            public void sleep(){
                System.out.println("睡觉");
            }
        }

b.创建一个代理类：

        //我们代理类里面定义和Person类里面一样的方法
        public class ProxyPerson {
            private Person p ;
            public ProxyPerson(Person p) {//将person对象传进来
                this.p = p ;
            }
            public void eat() {
                p.eat() ;
            }
            public void sleep(){
                p.sleep() ;
                System.out.println("睡5分钟");
            }
        }

c.使用：

        public class Test {
            public static void main(String[] args) {
                //没有使用代理
                Person p = new  Person();
                p.eat() ;
                p.sleep() ;

                //使用代理,
                ProxyPerson pp = new ProxyPerson(p) ;
                pp.eat() ;
                pp.sleep() ;//除了打印“睡觉” 还会打印“睡5分钟”
            }
        }

注意：和包装类相似，只不过我们写了和被包装类一样的方法，而不是实现接口。

5、扩展已知类功能-动态代理

简单代码演示下动态代理的原理
    a.有个通用的接口

            public interface Human {
                public void eat() ;
                public void sing(float money) ;
                public void dance(float money) ;
            }

    b.一个实现类（可以理解 歌手）

            public class SpringBrother implements Human {
                @Override
                public void eat() {
                    System.out.println("吃饭");
                }
                @Override
                public void sing(float money) {
                    System.out.println("拿到" + money);
                }
                @Override
                public void dance(float money) {
                    System.out.println("拿到" + money);
                }
            }

    c.代理类（可理解为经纪人）

            //模拟动态代理的原理
            public class ProxyHuman implements Human {
                private Human man ;
                public ProxyHuman(Human man) {
                    this.man = man ;
                }
                @Override
                public void eat() {
                    man.eat() ;
                }
                @Override
                public void sing(float money) {
                    if(money > 1000)
                        man.sing(money/2) ;
                }
                @Override
                public void dance(float money) {
                    if(money > 2000)
                        man.sing(money/2) ;
                }
            }

    d.使用代理类

            public class Test {
                public static void main(String[] args) {
                    Human man = new ProxyHuman(new SpringBrother()) ;
                    man.eat() ;
                    man.sing(2000) ;
                    man.dance(4000) ;
                }
            }

实际的应用中是没有ProxyHuman这个代理类的，java虚拟机帮我们做了，我们需要使用Proxy类
代码演示：基于接口的动态代理

        public class Test {
            public static void main(String[] args) {
                //定义为final是为了下面匿名内部类可以调用
                final SpringBrother sb = new SpringBrother() ;
                //可以查看帮助文档，看看参数
                Human man = (Human)Proxy.newProxyInstance(sb.getClass().getClassLoader(),
                        sb.getClass().getInterfaces(), 
                        new InvocationHandler() {
                        /**
                         * invoke(Object proxy, Method method, Object[] args)
                         * proxy: 代理人
                         * method: 代理的方法
                         * args: 方法的参数
                         */
                            @Override
                            public Object invoke(Object proxy, Method method, Object[] args)
                                    throws Throwable {
                                if(method.getName().equals("sing")){//唱歌方法
                                    float money = (Float)args[0] ;
                                    if(money > 1000){
                                        Object retVal = method.invoke(sb, money/2) ;
                                        return retVal;
                                    }else
                                        return null ;
                                }
                                if(method.getName().equals("dance")){//跳舞方法
                                    float money = (Float)args[0] ;
                                    if(money > 2000){
                                        Object retVal = method.invoke(sb, money/2) ;
                                        return retVal ;
                                    }else
                                        return null ;
                                }
                                Object ret =method.invoke(sb, args) ;
                                return ret ;
                            }
                        }) ;
                man.eat() ;
                man.sing(1500) ;
                man.dance(2500) ;
            }
        }

其实也很简单，我们是用了java提供了类来实现了动态代理的功能
基于子类的动态代理可以使用第三方包net.sf.cglib.proxy.Enhancer来实现，就不演示了。

注意：我们动态代理就是给某个特定的方法设个条件是否执行，或者在调用这个close方法的时候不执行，来执行我们自己的代码。
    就相当于包装类里面，我们重新实现了接口里面的close方法。

6、使用动态代理改造我们的 MyDataDource2 类：

例如：

        public class MyDataDource2 implements DataSource{
            private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
            static{//写一个静态块，默认放10个连接
                for (int i = 0; i < 10; i++) {
                    Connection conn = JdbcUtils.getConnection() ;
                    pool.add(conn) ;
                }
            }
            @Override
            public Connection getConnection() throws SQLException {
                if(pool.size() > 0 ){
                    //定义为final，便于匿名内部类使用
                    final Connection conn = pool.removeFirst() ;  //右边： com.mysql.jdbc.Connection
                    //采用动态代理
                    Connection ProxyConn =  (Connection)Proxy.newProxyInstance(conn.getClass().getClassLoader(),
                             conn.getClass().getInterfaces(), 
                             new InvocationHandler() {
                                @Override
                                public Object invoke(Object arg0, Method method, Object[] args)
                                        throws Throwable {
                                    if(method.getName().equals("close")){
                                        //不要关闭，而是放回池中
                                        pool.add(conn) ;
                                        return null ;
                                    }
                                    Object retVal = method.invoke(conn, args) ;
                                    return retVal ;
                                }
                            }) ;
                    return ProxyConn;
                }else
                    throw new RuntimeException("对不起,服务器忙") ;
            }
            //未实现的一些方法
        }

7、DBCP数据源：

第三方提供的数据源
使用步骤：
a.将jar包拷贝到当前工程
    commons-dbcp-1.4.jar
    commons-pool-1.5.6.jar
b.在src目录下创建一个配置文件 dfcpconfig.properties
    #连接设置
    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/test
    username=root
    password=root
    #<!-- 初始化连接 -->
    initialSize=10
    #最大连接数量
    maxActive=50
    #<!-- 最大空闲连接 -->
    maxIdle=20
    #<!-- 最小空闲连接 -->
    minIdle=5
    #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
    maxWait=60000
    #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
    #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
    connectionProperties=useUnicode=true;characterEncoding=gbk

    #指定由连接池所创建的连接的自动提交（auto-commit）状态。
    defaultAutoCommit=true

    #driver default 指定由连接池所创建的连接的只读（read-only）状态。
    #如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
    defaultReadOnly=false

    #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
    #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
    defaultTransactionIsolation=READ_UNCOMMITTED

c.创建一个连接的工具类

        public class DBCPUtils {
            private static DataSource ds ;
            static {
                //将配置文件加载进来
                InputStream in = DBCPUtils.class.getClassLoader().getResourceAsStream("dbcpconfig.properties") ;
                Properties props = new Properties() ;
                try {
                    props.load(in) ;
                    ds = BasicDataSourceFactory.createDataSource(props) ;
                } catch (Exception e) {
                    throw new RuntimeException("服务器忙") ;
                }
            }

            //提供获取练级的方法
            public static Connection getConnection(){
                try {
                    return ds.getConnection() ;
                } catch (SQLException e) {
                    throw new RuntimeException("服务器忙") ;
                }
            }
        }

d.使用

        public class TestDBCPUtils {
            public static void main(String[] args) {
                Connection conn = DBCPUtils.getConnection() ;
                System.out.println(conn.getClass().getName());
            }
        }

8、C3P0数据源：

第三方数据源
和上面的方法类似
a.拷贝jar包
b.在src目录下创建配置文件 c3p0-config.xml

        <?xml version="1.0" encoding="UTF-8"?>
        <c3p0-config>
            <default-config>
                <property name="driverClass">com.mysql.jdbc.Driver</property>
                <property name="jdbcUrl">jdbc:mysql://localhost:3306/day16</property>
                <property name="user">root</property>
                <property name="password">root</property>

                <property name="acquireIncrement">5</property>
                <property name="initialPoolSize">10</property>
                <property name="minPoolSize">5</property>
                <property name="maxPoolSize">20</property>
            </default-config>

            <named-config name="mysql">
                <property name="driverClass">com.mysql.jdbc.Driver</property>
                <property name="jdbcUrl">jdbc:mysql://localhost:3306/day16</property>
                <property name="user">root</property>
                <property name="password">root</property>

                <property name="acquireIncrement">5</property>
                <property name="initialPoolSize">10</property>
                <property name="minPoolSize">5</property>
                <property name="maxPoolSize">20</property>
            </named-config>


            <named-config name="oracle">
                <property name="driverClass">com.mysql.jdbc.Driver</property>
                <property name="jdbcUrl">jdbc:mysql://localhost:3306/day16</property>
                <property name="user">root</property>
                <property name="password">root</property>

                <property name="acquireIncrement">5</property>
                <property name="initialPoolSize">10</property>
                <property name="minPoolSize">5</property>
                <property name="maxPoolSize">20</property>
            </named-config>
        </c3p0-config>

c.创建工具类

        public class C3p0Utils {
            private static DataSource ds ;
            static{
                ds = new ComboPooledDataSource() ;
            }

            //提供获取连接的方法
            public static Connection getConnection(){
                try {
                    return ds.getConnection() ;
                } catch (SQLException e) {
                    throw new RuntimeException("服务器忙") ;
                }
            }
        }

d.使用：

        public class TestC3p0Utils {
            public static void main(String[] args) {
                Connection conn = C3p0Utils.getConnection() ;
                System.out.println(conn.getClass().getName());
            }
        }

上面两种情况是在java工程里面使用第三方的数据源，我们web工程里面可以使用tomcat自带的数据源

9、tomcat数据源的配置

tomcat里面已经有了dbcp的jar包了
D:\tomcat\apache-tomcat-7.0.77\lib\tomcat-dbcp.jar

步骤：
    a、拷贝数据库驱动jar包到Tomcat\lib目录下
    b、在应用的META-INF目录下建立一个名称为context.xml的配置文件。

            可以查看帮助文档
            <?xml version = "1.0"?>
            <Context>
              <Resource name="jdbc/day16" auth="Container" type="javax.sql.DataSource"
                           maxActive="100" maxIdle="30" maxWait="10000"
                           username="root" password="root" driverClassName="com.mysql.jdbc.Driver"
                           url="jdbc:mysql://localhost:3306/test"/>

            </Context>

    c、启动Tomcat，数据源就给你建好了
    d、在应用中如何获取数据源，jsp页面中使用

            <%
                Context initContext = new InitialContext();
                Context envContext = (Context) initContext.lookup("java:/comp/env");
                DataSource ds = (DataSource) envContext.lookup("jdbc/test");
                Connection conn = ds.getConnection();
                out.write(conn.toString() + "jjjjj") ;
            %>

    注意：不要在main方法中获取数据源，获取不到。因为main调用重新开了个虚拟机。

10、数据库元数据的获取:

MetaData
元数据：数据库、表、列等定义的信息
例如：
数据库的元信息：DatabaseMetaData

        Connection conn = DBCPUtils.getConnection();// 获取连接对象
        DatabaseMetaData dbmd = conn.getMetaData();// 获取DataBaseMetaData对象
        String name = dbmd.getDatabaseProductName();// 获取数据库产品的名称

获取PreparedStatement占位符的元信息

        Connection conn = DBCPUtils.getConnection();// 获取连接对象
        PreparedStatement pstmt = conn.prepareStatement("??????");// 创建预处理对象
        ParameterMetaData pmd = pstmt.getParameterMetaData();// 获取ParameterMetaData对象
        int n = pmd.getParameterCount();// 获取参数的个数

等等，我们其实都可以通过方法的名称就知道。

11、自定义JDBC的框架

之前我们DaoImpl里面的数据库操作很麻烦，而且很多重复，我们可以封装下。
这个地方我们就用到元数据了，可以动态的获取参数个数，返回查询结果的字段名称等。

我们新建一个DBAsssist类，里面把一些连接，执行sql语句的逻辑放进来

        //自定义框架
        public class DBAsssist {
            // 执行添改删语句，定义可变参数好处就是，有参数就传，没有就不传
            public boolean update(String sql, Object... params) {
                Connection conn = DBCPUtils.getConnection();// 拿到连接对象
                int t = 0;
                try {
                    // 创建预处理命令对象
                    PreparedStatement pstmt = conn.prepareStatement(sql);
                    // 对?进行赋值
                    // 获取ParameterMetaData对象
                    ParameterMetaData pmd = pstmt.getParameterMetaData();
                    int n = pmd.getParameterCount();// 拿到?的个数
                    if (n > 0) {
                        if (params == null || params.length != n) {// sql语句里有?号
                            throw new RuntimeException("参数的个数不匹配");
                        }

                        for (int i = 0; i < n; i++) {// 依次给每个?赋值
                            pstmt.setObject(i + 1, params[i]);
                        }
                    }
                    t = pstmt.executeUpdate();//执行sql语句
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        conn.close(); // 还回池中了
                    } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                return t > 0 ? true : false;
            }

            //查询的就不演示了
        }

使用：

        @Test
        public void test() {
            DBAsssist db = new DBAsssist();
            db.update("insert into account(id,name,money) values(?,?,?)", 1, "张三",2000);
        }

后面我们可以把我们写好的类打包成jar包，其他的工程就可以使用了。

pin-csdn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
web 学习笔记16-JDBC连接池扩展已知类

JDBC连接池扩展已知类（装饰模式、适配器模式、动态代理）,常见的数据源自定义JDBC框架（封装增删改查）
复制链接

扫一扫

专栏目录

web 学习笔记16-JDBC连接池 扩展已知类

“相关推荐”对你有帮助么？

web 学习笔记16-JDBC连接池扩展已知类