[javaEE] 数据库连接池和动态代理详解编程语言

实现Connection getConnection()方法

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

import java.lang.reflect.InvocationHandler; 

import java.lang.reflect.Method; 

import java.lang.reflect.Proxy; 

import java.sql.Connection; 

import java.sql.ResultSet; 

import java.sql.Statement; 

public class JDBCTest { 

 public 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); 

}

我的连接池

import java.io.PrintWriter; 

import java.sql.Connection; 

import java.sql.DriverManager; 

import java.sql.SQLException; 

import java.sql.SQLFeatureNotSupportedException; 

import java.util.LinkedList; 

import java.util.List; 

import java.util.logging.Logger; 

import javax.sql.DataSource; 

 * 手写连接池 

 * @author taoshihan 

public class MyPool implements DataSource { 

 // 连接池 

 public static List Connection pool = new LinkedList Connection (); 

 // 初始化 

 static { 

 try { 

 Class.forName("com.mysql.jdbc.Driver"); 

 for (int i = 0; i i++) { 

 Connection conn = DriverManager.getConnection( 

 "jdbc:mysql://localhost:3306/java", "root", "root"); 

 pool.add(conn); 

 } catch (Exception e) { 

 /** 

 * 获取连接 

 @Override 

 public Connection getConnection() throws SQLException { 

 // 如果池中没有连接 

 if (pool.size() == 0) { 

 for (int i = 0; i i++) { 

 Connection conn = DriverManager.getConnection( 

 "jdbc:mysql://localhost:3306/java", "root", "root"); 

 pool.add(conn); 

 //先进先出 

 Connection conn=pool.remove(0); 

 System.out.println("获取一个连接，池里还剩余"+pool.size()); 

 return conn; 

 /** 

 * 重置连接 

 public void resetConn(Connection conn){ 

 try { 

 if(conn!=null !conn.isClosed()){ 

 pool.add(conn); 

 System.out.println("还回一个连接，池里还剩余"+pool.size()); 

 } catch (Exception e) { 

 e.printStackTrace(); 

 @Override 

 public Connection getConnection(String username, String password) 

 throws SQLException { 

 return null; 

 @Override 

 public PrintWriter getLogWriter() throws SQLException { 

 // TODO Auto-generated method stub 

 return null; 

 @Override 

 public void setLogWriter(PrintWriter out) throws SQLException { 

 // TODO Auto-generated method stub 

 @Override 

 public void setLoginTimeout(int seconds) throws SQLException { 

 // TODO Auto-generated method stub 

 @Override 

 public int getLoginTimeout() throws SQLException { 

 // TODO Auto-generated method stub 

 return 0; 

 @Override 

 public Logger getParentLogger() throws SQLFeatureNotSupportedException { 

 // TODO Auto-generated method stub 

 return null; 

 @Override 

 public T T unwrap(Class T iface) throws SQLException { 

 // TODO Auto-generated method stub 

 return null; 

 @Override 

 public boolean isWrapperFor(Class ? iface) throws SQLException { 

 // TODO Auto-generated method stub 

 return false; 

}

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

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

装饰的测试实现：

import java.lang.reflect.InvocationHandler; 

import java.lang.reflect.Method; 

import java.lang.reflect.Proxy; 

import java.sql.Connection; 

import java.sql.ResultSet; 

import java.sql.Statement; 

public class JDBCTest { 

 public static void main(String[] args) throws Exception { 

 //测试装饰模式 

 Animal dog=new BigDog(new Dog()); 

 dog.eat(); 

 dog.sound(); 

 * 装饰模式测试 

 * @author taoshihan 

interface Animal{ 

 public void eat(); 

 public void sound(); 

class Dog implements Animal{ 

 @Override 

 public void eat() { 

 System.out.println("吃"); 

 @Override 

 public void sound() { 

 System.out.println("汪"); 

//此时我想修改Dog类中的sound方法 

class BigDog implements Animal{ 

 private Dog dog; 

 public BigDog(Dog dog) { 

 this.dog=dog; 

 /** 

 * 这个方法调原来的 

 @Override 

 public void eat() { 

 dog.eat(); 

 /** 

 * 这个方法进行装饰 

 @Override 

 public void sound() { 

 System.out.println("大叫"); 

}

动态代理：

 

 //测试代理模式 

 final Dog dog=new Dog(); 

 Animal proxy=(Animal) Proxy.newProxyInstance(Dog.class.getClassLoader(),Dog.class.getInterfaces() , new InvocationHandler() { 

 @Override 

 public Object invoke(Object proxy, Method method, Object[] args) 

 throws Throwable { 

 if("sound".equals(method.getName())){ 

 System.out.println("大叫"); 

 return null; 

 }else{ 

 return method.invoke(dog, args); 

 }); 

 proxy.eat(); 

 proxy.sound();

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/12629.html