[javaEE] 数据库连接池和动态代理

实现javax.sql.DataSource接口

实现Connection getConnection()方法

定义一个静态的成员属性LinkedList类型作为连接池，在静态代码块中初始化5条数据库连接，添加到连接池中，在getConnection方法中，当获取连接的时候在连接池中remove掉一条连接就可以了

import java.lang.reflect.InvocationHandler;
 java.lang.reflect.Method;
 java.lang.reflect.Proxy;
 java.sql.Connection;
 java.sql.ResultSet;
 java.sql.Statement;

public class JDBCTest {
    static void main(String[] args) throws Exception {
        //使用反射的方式
        Class.forName("com.mysql.jdbc.Driver");
        获取数据库连接，导包的时候，注意要导java.sql下的，面向接口编程
        MyPool pool=new MyPool();
        Connection conn=pool.getConnection();
        获取传输器对象
        Statement statement=conn.createStatement();
        获取结果集对象
        ResultSet resultSet=statement.executeQuery("select * from user"遍历
        while(resultSet.next()){
            String username=resultSet.getString("username");
            System.out.println(username);
        }
        关闭资源
        resultSet.close();
        statement.close();
        pool.resetConn(conn);
        
    }
}

我的连接池

 java.io.PrintWriter;
 java.sql.DriverManager;
 java.sql.SQLException;
 java.sql.SQLFeatureNotSupportedException;
 java.util.LinkedList;
 java.util.List;
 java.util.logging.Logger;

 javax.sql.DataSource;

/**
 * 手写连接池
 * 
 * @author taoshihan
 * 
 */
class MyPool implements DataSource {
     连接池
    static List<Connection> pool = new LinkedList<Connection>();
     初始化
    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            for (int i = 0; i < 5; i++) {
                Connection conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/java","root","root");
                pool.add(conn);
            }
        } catch (Exception e) {
        }
    }

    
     * 获取连接
     */
    @Override
    public Connection getConnection()  SQLException {
         如果池中没有连接
        if (pool.size() == 0) {
            );
                pool.add(conn);
            }
        }
        先进先出
        Connection conn=pool.remove(0);
        System.out.println("获取一个连接，池里还剩余"+pool.size());
        return conn;
    }
    
     * 重置连接
     */
    void resetConn(Connection conn){
         {
            if(conn!=null && !conn.isClosed()){
                pool.add(conn);
                System.out.println("还回一个连接，池里还剩余"+pool.size());
            }
        }  (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public Connection getConnection(String username,String password)
             SQLException {
                return null;
    }

    @Override
    public PrintWriter getLogWriter()  TODO Auto-generated method stub
        void setLogWriter(PrintWriter out)  TODO Auto-generated method stub

    }

    @Override
    void setLoginTimeout(int seconds) int getLoginTimeout() return 0public Logger getParentLogger()  SQLFeatureNotSupportedException {
        public <T> T unwrap(Class<T> iface) boolean isWrapperFor(Class<?> iface) false;
    }

}

 

 

使用继承，装饰，动态代理改造一个类中的方法

继承的缺点：此时我们已经得到了Connection对象，因此无法通过继承改造这个对象

装饰的测试实现：

 Exception {
        
        测试装饰模式
        Animal dog=new BigDog( Dog());
        dog.eat();
        dog.sound();

    }
}


 * 装饰模式测试
 *  taoshihan
 *
 interface Animal{
     eat();
     sound();
}
class Dog  Animal{

    @Override
     eat() {
        System.out.println("吃");
    }

    @Override
     sound() {
        System.out.println("汪");
    }
}
此时我想修改Dog类中的sound方法
class BigDog private Dog dog;
     BigDog(Dog dog) {
        this.dog=dog;
    }
    
     * 这个方法调原来的
      eat() {
        dog.eat();
    }
    
     * 这个方法进行装饰
     

    @Override
     sound() {
        System.out.println("大叫");
    }
    
}

动态代理：

        
        测试代理模式
        final Dog dog= Dog();
        Animal proxy=(Animal) Proxy.newProxyInstance(Dog.class.getClassLoader(),Dog.class.getInterfaces(), InvocationHandler() {
            
            @Override
             Object invoke(Object proxy,Method method,Object[] args)
                     Throwable {
                if("sound".equals(method.getName())){
                    System.out.println("大叫");
                    ;
                }else{
                     method.invoke(dog,args);
                }
            }
        });
        proxy.eat();
        proxy.sound();