디자인 모드 의 프 록 시 모드 (자신의 데이터베이스 연결 풀 실현)

자신의 데이터베이스 연결 탱크 를 작성 할 때 우 리 는 먼저 데이터베이스 연결 탱크 가 무엇 인지 알 아 보 겠 습 니 다. 데이터베이스 연결 탱크 를 모 의 합 니 다.

public class SimpleConnectionPool {
    private static List<Connection> listConnection = new ArrayList<Connection>();
   //   10     
    static {
        for (int i = 0; i < 10; i++) {
            Connection e = MyJdbcUtil.getConnection();
            listConnection.add(e);
        }
    }
//    
    public static  synchronized  Connection getConnection(){
                   if(listConnection.size()>0){
                            Connection con = listConnection.get(0);
                            listConnection.remove(0);
                           return con;
                   }else{
                       throw new RuntimeException("     ");
                   }
       }
    //    
    public static synchronized void closeConnection(Connection connection){
              listConnection.add(connection);
    }
    public static List<Connection> getListConnection() {
        return listConnection;
    }

}

테스트:

@Test
    public void test() {
        System.out.println(SimpleConnectionPool.getListConnection().size());
        //10
       Connection connection=  SimpleConnectionPool.getConnection();//    
     System.out.println(SimpleConnectionPool.getListConnection().size());//9
      SimpleConnectionPool.closeConnection(connection);//    
      System.out.println(SimpleConnectionPool.getListConnection().size());
      //10

    }

현재 우 리 는 표준 데이터 원본 을 만 들 었 습 니 다. 1. SUN 회 사 는 표준 을 정 의 했 습 니 다. 자바. sql. dataSource 는 이 인 터 페 이 스 를 실현 하 는 것 이 표준 데이터베이스 연결 풀 입 니 다. 이 DataSource 를 실현 한 후에 연 결 된 getConnection () 만 가 져 오 면 우리 가 보 여 준 반환 연결 이 없습니다. 그래서 우 리 는 connection. close () 만 사용 합 니 다.연결 을 풀 수 있 는 방법 이지 만 기본적으로 연결 을 닫 을 수 밖 에 없습니다.풀 에 돌려 줄 수 없습니다. 여기 서 필요 한 것 이 있 습 니 다. 1. 이미 알 고 있 는 유형의 특정한 방법 이나 특정한 방법 (기 존의 코드 를 수정 할 수 없고 확장 해 야 합 니 다) 을 변경 하 는 몇 가지 해결 방안 이 있 습 니 다. a: 계승: 여 기 는 안 됩 니 다. b: 포장 디자인 모델 (장식 디자인 모델) 또는 어댑터 모델 c: 동적 대 리 를 이용 합 니 다.
우 리 는 먼저 장식 자 모드 를 사용한다.

     ：     
                   a、            （com.mysql.jdbc.Connection）     
                   b、      ，         
                   c、      ，           
                   d、        ，         
                   e、          ，           

코드 예제:

//a、            （com.mysql.jdbc.Connection）     
public class MyConnection implements Connection {
    // b、      ，         
    private Connection connection;
    private List<Connection> list;
// c、      ，           
    public MyConnection(Connection connection, List<Connection> list) {
        super();
        this.connection = connection;
        this.list = list;
    }
    //d、        ，         
    @Override
    public void close() throws SQLException {
        list.add(connection);
    }
//e、          ，           
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        // TODO Auto-generated method stub
        return connection.unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        // TODO Auto-generated method stub
        return connection.isWrapperFor(iface);
    }
    ....

}

지금 우 리 는 우리 의 연결 탱크 를 보 러 왔 다.

public class MyDataSource implements DataSource{
    //   10   
    private static List<Connection> listConnection =Collections.synchronizedList(new ArrayList<Connection>());
    static {
        for (int i = 0; i < 10; i++) {
            Connection e = MyJdbcUtil.getConnection();
            listConnection.add(e);
        }
    }
    @Override
    public Connection getConnection() throws SQLException {
          if(listConnection.size()>0){
            Connection con = listConnection.get(0);
             listConnection.remove(0);
             //           
              MyConnection myConnection = new MyConnection(con, listConnection);
             return myConnection;
     }else{
       throw new RuntimeException("     ");
     }
    }

현재 어댑터 모드 를 사용 합 니 다:
1) 먼저 Connection 의 어댑터 를 쓰 십시오. 어댑터 의 구결 은 포장 류 / a 입 니 다. 포장 류 (com. my sql. jdbc. Connection) 와 같은 인터페이스 / / b 를 만 들 고 변 수 를 정의 합 니 다. 포장 류 의 인 스 턴 스 / c, 정의 구조 방법 을 참조 하여 포장 류 인 스 턴 스 의 인용 / d, 모든 방법 을 입력 합 니 다.기 존 대상 의 대응 방법 을 호출 하 다.

//a、            （com.mysql.jdbc.Connection）     
public  class MyConnectionAdapet implements Connection{
    //b、      ，          
    private Connection connection;
    //c、      ，           
    public MyConnectionAdapet(Connection connection) {
      this.connection=connection;
} 
    //d、       ，           
    @Override
    public void close() throws SQLException {
             connection.close();
    }

이제 어댑터 를 통 해 close () 방법 구결 을 수정 합 니 다.피 포장 류 의 인 스 턴 스 / c, 정의 구조 방법 을 참조 하여 피 포장 류 인 스 턴 스 의 인용 / d, 변경 할 방법 에 대해 덮어 쓰 면 됩 니 다.

//a、                （com.mysql.jdbc.Connection）        (    )
public class MyConnection2 extends MyConnectionAdapet{
    //b、      ，         
   private Connection connection;
   private List<Connection> liConnections;
 //c、      ，           
    public MyConnection2(Connection connection, List listConnection) {
        // TODO Auto-generated constructor stub
        super(connection);
        this.connection=connection;
        this.liConnections=listConnection;
    }
     //d、        ，    
    @Override
    public void close() throws SQLException {
        // TODO Auto-generated method stub
         liConnections.add(connection);
    }

}

위 와 같이 데이터 원본 에서 Connection 에서 close 를 바 꾸 는 방법 을 실현 합 니 다.우리 가 사용 하 는 것 은 모두 정적 프 록 시 입 니 다. 현재 우 리 는 동적 프 록 시 를 사용 합 니 다. 인터페이스 기반 동적 프 록 시 라 고도 할 수 있 습 니 다. 인터페이스 가 없 기 때문에 프 록 시 를 실현 할 수 없습니다. 동적 프 록 시 는 표시 되 지 않 는 프 록 시 클래스 입 니 다.

//       ：
public class MyDataSource implements DataSource {

    private static List<Connection> listConnection = Collections.synchronizedList(new ArrayList<Connection>());
   //   10     
    static {
        for (int i = 0; i < 10; i++) {
            Connection e = MyJdbcUtil.getConnection();
            listConnection.add(e);
        }
    }

    @Override
    public Connection getConnection() throws SQLException {
        if (listConnection.size() > 0) {
            final Connection con = listConnection.get(0);
            listConnection.remove(0);
            //    Connection
            //Proxy    newProxyInstance             。
            //        :
            //  1.         ，    :        
            //  2.         ，    :                  (                 )
            //  3.     ，    ，    ，              
            return (Connection) Proxy.newProxyInstance(con.getClass().getClassLoader(), con.getClass().getInterfaces(),
                    new InvocationHandler() {
                //       
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            //                  
                            //   ，        
                            //  1.       
                            //  2.            
                            //  3.       
                            if ("close".equals(method.getName())) {
                                return listConnection.add(con);
                            }
                            return method.invoke(con, args);

                        }
                    });
        } else {
            throw new RuntimeException("     ");
        }
    }

    public static List<Connection> getListConnection() {
        return listConnection;
    }
..
}

위 와 같이 디자인 모델 의 대리 모델 의 응용 이다.