JDBC 의 확장 지식 포인트 총화

14577 단어 JDBC사용법
데이터베이스
1.1 사무 개요
  • 사무:논리 조작 장치 로 데 이 터 를 한 상태 에서 다른 상태 로 바 꿉 니 다
  • 사무 처리(사무 조작):모든 사 무 를 하나의 작업 단위 로 수행 하도록 보장 합 니 다.고장 이 나 도 이런 집행 방식 을 바 꿀 수 없습니다.한 업무 에서 여러 작업 을 수행 할 때,모든 업무 가 제출 되 거나(commt)이 변경 사항 은 영구적 으로 저 장 됩 니 다.데이터베이스 관리 시스템 이 모든 수정 을 포기 하거나 전체 트 랜 잭 션 스크롤 백(rollback)을 초기 상태
  • 으로 되 돌 립 니 다.
  • 데이터베이스 에 있 는 데이터 의 일치 성 을 확보 하기 위해 데이터 의 조작 은 분 산 된 그룹의 논리 적 단원 이 어야 한다.이 단원 이 모두 완성 되면 데이터 의 일치 성 을 유지 할 수 있 고 이 단원 의 일부 조작 이 실패 하면 전체 사 무 는 모두 오류 로 간주 해 야 한다.시작 점 이후 의 조작 은 모두 시작 상태
  • 으로 되 돌아 가 야 한다.
  • 밤 을 들 어 샤 오 밍 이 샤 오 홍 에 게 이 체 를 할 때 여러 가지 이유 로 이체 에 성공 하지 못 해서 샤 오 밍 의 돈 이 줄 었 지만 샤 오 홍 은 돈 을 받 지 못 했다.이때 업무 가 다시 굴 러 가 야 한다.그렇지 않 으 면 샤 오 밍 은 울 어서 죽 을 것 이다.
  • 1.2 트 랜 잭 션 속성
    트 랜 잭 션 의 ACID(acid)속성
  • 원자 성(Atomicity)
  • 원자 성 이란 사 무 는 분리 할 수 없 는 업무 단위 로 업무 중의 조작 이 모두 발생 하거나 발생 하지 않 는 다 는 것 을 말한다.
  • 일치 성(Consistency)
  • 사 무 는 데이터 베 이 스 를 하나의 일치 성 상태 에서 다른 일치 성 상태 로 바 꿔 야 한다.
  • 격 리 성(Isolation)
  • 업무 의 격 리 성 은 한 업무 의 집행 이 다른 업무 에 의 해 방 해 받 지 못 하 는 것 을 말한다.즉,한 업무 내부 의 조작 과 사용 하 는 데 이 터 는 병발 하 는 다른 업무 에 대해 격 리 되 고 병발 하 는 각 업무 간 에 서로 간섭 할 수 없다.
  • 지속 성(Durability)
  • 지속 성 이란 하나의 업무 가 제출 되면 데이터 베이스 에서 의 데이터 변화 가 영구적 인 것 을 말 하 며,다음 의 다른 조작 과 데이터 베이스 고장 은 그 에 게 어떠한 영향 도 주어 서 는 안 된다.
  • 1.3 JDBC 사무 처리
    연결 대상 이 생 성 되 었 을 때 기본 값 으로 자동 으로 업 무 를 제출 합 니 다.SQL 문 구 를 실행 할 때마다 실행 에 성공 하면 데이터베이스 에 자동 으로 제출 되 며 스크롤 백 할 수 없습니다.
    여러 SQL 문 구 를 하나의 사무 로 실행 하기 위해 서:
    1.Connection 대상 의 setAutoCommit(false)를 호출 합 니 다.자동 제출 취소
    2.모든 SQL 문 구 를 성공 적 으로 실행 한 후 commt()를 호출 합 니 다.방법 제출 사무
    3.이상 이 발생 했 을 때 rollback()을 호출 합 니 다.방법 스크롤 백 트 랜 잭 션
    4.이때 Connection 이 닫 히 지 않 으 면 자동 제출 상 태 를 회복 해 야 합 니 다.
    1.4 데이터베이스 트 랜 잭 션 사용 과정
    데이터 베 이 스 를 사용 하 는 사무,우 리 는 이상 처리 try 에 협조 해 야 합 니 다.
    
    public void testJDBCTransaction() {
    Connection conn = null;
    try {
    // 1.       
    conn = JDBCUtils.getConnection();
    // 2.    
    conn.setAutoCommit(false);
    // 3.       
    
    // 4.     ,     
    conn.commit();
    } catch (Exception e) {
    e.printStackTrace();
    // 5.    ,     
    try {
    conn.rollback();
    } catch (SQLException e1) {
    e1.printStackTrace();
    }} finally {
    JDBCUtils.close(null, null, conn); }  }
    
    1.5 데이터베이스 사용 의 장점
    COMMIT 와 ROLLBACK 문 구 를 사용 하면 다음 과 같이 할 수 있 습 니 다.
  • 데이터 완전 성 확보.
  • 데이터 변경 제출 전 미리 보기.
  • 은 논리 적 으로 관련 된 조작 을
  • 으로 나 누 었 다.
    제출 또는 스크롤 백 전 데이터 상태
  • 변경 전 데이터 상 태 는 회복 가능 한
  • 입 니 다.
  • DML 작업 을 수행 하 는 사용 자 는 SELECT 문 구 를 통 해 제출 하거나 스크롤 백 하기 전의 수정
  • 을 조회 할 수 있 습 니 다.
  • 다른 사용 자 는 현재 사용자 가 일 을 끝 낼 때 까지 현재 사용자 가 한 변 화 를 볼 수 없습니다.
  • DML 구문 과 관련 된 줄 이 잠 겨 있 고 다른 사용 자 는
  • 을 조작 할 수 없습니다.
    제출 후 데이터 상태
  • 데이터 의 변 화 는 데이터베이스 에 저장 되 었 습 니 다.
  • 변경 전의 데 이 터 를 잃 어 버 렸 습 니 다.
  • 모든 사용자 가 결 과 를 볼 수 있 습 니 다.
  • 자물쇠 가 풀 려 나 고 다른 사용자 가 관련 된 데 이 터 를 조작 할 수 있 습 니 다
  • 이렇게 많은 말 을 했 는데 도 코드 를 사용 하여 예 를 들 어 더욱 명확 하 게 설명 합 니 다.
    
    package com.company.jdbcDemo;
    
    import com.company.jdbcDemo.JDBCUtils;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    /*
        AA CC  1000
        AA 2000
        CC 2000
    
            try{
                   
               AA -= 1000
               System.out.println(1/0);
               CC += 1000
                 (           (  ))
            }catch(Exception e){
                (  )
            }
    
        CREATE TABLE account(
        NAME VARCHAR(20),
        balance INT
        )
    
     */
    public class AccountDemo {
    
        public static void main(String[] args) throws SQLException {
            //1.         
            Connection connection = JDBCUtils.getConnection();
            PreparedStatement ps = null;
            try {
                //2.    --      
                connection.setAutoCommit(false);
                //-------------------------------------------------------------------
                //3.      ---  sql  
                //   
                String sql = "update account set balance=? where name=?";
                ps = connection.prepareStatement(sql);
    
                //      
                ps.setInt(1, 1000);
                ps.setString(2, "aa");
                //  sql
                ps.executeUpdate();
    
                System.out.println(1 / 0);
    
                //      
                ps.setInt(1, 3000);
                ps.setString(2, "cc");
                //  sql
                ps.executeUpdate();
                //-------------------------------------------------------------------
                //4.    
                connection.commit();
            }catch (Exception e){
                e.printStackTrace();
                //5.    
                connection.rollback();
            }finally {
                //6.      
                connection.setAutoCommit(true);
                //7.    ----      
                JDBCUtils.close(ps,connection);
    
            }
        }
    }
    
    2.데이터베이스 연결 탱크
    개술
    앞에서 우리 의 예제 코드 에서 내 가 쓴 JDBCutils 류 를 호출 하여 데이터 베 이 스 를 연결 해 왔 다.만약 에 우리 가 다른 프로젝트 에서 나의 그 종 류 를 복사 해 야 한다.그리고 내 가 쓴 것 도 엄밀 하지 않다.내 가 앞에서 실현 한 데이터 베이스 연결 방식 에 다음 과 같은 문제 가 존재 한다.
  •  일반적인 JDBC 데이터베이스 연결 은 DriverManager 를 사용 하여 가 져 옵 니 다.데이터베이스 에 연결 할 때마다 Connection 을 메모리 에 불 러 오고 사용자 이름과 비밀 번 호 를
  • 으로 검증 합 니 다.
  • 데이터 베 이 스 를 연결 하 는 자원 은 좋 은 중복 이용 을 받 지 못 했다.만약 에 수백 명,심지어 수천 명 이 온라인 에 있 으 면 데이터 베 이 스 를 자주 연결 하 는 작업 은 많은 시스템 자원 을 차지 하고 심각 한 것 은 서버 의 붕 괴 를 초래 할 수도 있다.
  • 은 매번 데이터베이스 연결 에 대해 사용 이 끝 난 후에 끊 어야 한다.그렇지 않 으 면 프로그램 에 이상 이 생 겨 서 닫 지 못 하면 데이터베이스 시스템 의 메모리 가 누 출 되 고 결국은 데이터 베 이 스 를 다시 시작 하 는
  • 을 초래 할 것 이다.
  • 이러한 개발 은 만들어 진 연결 대상 수 를 제어 할 수 없 으 며 시스템 자원 은 연결 이 너무 많 으 면 메모리 누 출 을 초래 할 수도 있 고 서버 가
  • 에 붕 괴 될 수도 있다.
    데이터베이스 연결 풀 사용
  • 데이터베이스 연결 탱크 의 기본 사상 은 바로 데이터베이스 연결 을 위해'버퍼'를 구축 하 는 것 이다.버퍼 에 일정 수량의 연결 을 미리 넣 고 데이터 베 이 스 를 연결 해 야 할 때'버퍼'에서 하 나 를 꺼 내 고 사용 이 끝 난 후에
  • 으로 돌려 보 냅 니 다.
  • 데이터베이스 연결 탱크 는 데이터베이스 연결 을 분배,관리,방출 하 는 것 을 책임 집 니 다.이 는 응용 프로그램 이
  • 을 다시 만 드 는 것 이 아니 라 기 존의 데이터 베 이 스 를 중복 사용 할 수 있 습 니 다.
  • 데이터베이스 연결 탱크 는 초기 화 할 때 일정한 수량의 데이터 베 이 스 를 만들어 연결 탱크 에 연결 합 니 다.이 데이터 베 이 스 를 연결 하 는 수량 은 최소 데이터 베이스 연결 수 에 의 해 설 정 됩 니 다.이 데이터베이스 연결 이 사용 되 든 안 되 든 연결 탱크 는 적어도 이렇게 많은 연결 수량 을 확보 할 것 이다.연결 탱크 의 최대 데이터베이스 연결 수량 은 이 연결 탱크 가 차지 할 수 있 는 최대 연결 수 를 제한 합 니 다.응용 프로그램 이 연결 탱크 에 요청 한 연결 수가 최대 연결 수량 을 초과 할 때 이 요청 들 은 대기 열 에
  • 에 추 가 됩 니 다.
    2.1 데이터베이스 연결 탱크 기술 의 장점
  • 자원 중용
  • 데이터 베 이 스 를 재 활용 하여 빈번 한 생 성 을 피하 고 연결 로 인 한 대량의 성능 비용 을 방출 합 니 다.시스템 소 모 를 줄 이 는 토대 에서 다른 한편 으로 는 시스템 운행 환경의 안정성 도 증가 했다.
  • 빠 른 시스템 반응 속도
  • 데이터베이스 연결 탱크 는 초기 화 과정 에서 여러 개의 데이터 베 이 스 를 만들어 연결 탱크 에 준비 합 니 다.연결 초기 화 작업 이 완료 되 었 습 니 다.업무 요청 처리 에 있어 기 존의 사용 가능 한 연결 을 직접 이용 하여 데이터 베이스 연결 초기 화 와 방출 과정의 시간 소 비 를 피 함으로써 시스템 의 응답 시간
  • 을 감소 시 켰 다.
  • 새로운 자원 배분 수단
  • 다 중 응용 이 같은 데이터 베 이 스 를 공유 하 는 시스템 에 있어 응용 층 에서 데이터 베이스 연결 탱크 의 설정 을 통 해 특정한 응용 이 최대 사용 가능 한 데이터 베이스 연결 수의 제한 을 실현 하고 특정한 응용 이 모든 데이터 베이스 자원 을 독점 하 는
  • 을 피 할 수 있다.
  • 통 일 된 연결 관리 로 데이터베이스 연결 이 누설 되 지 않도록
  • 비교적 완선 한 데이터 베이스 연결 탱크 실현 에서 사전 점용 시간 초과 설정 에 따라 점용 연결 을 강제 회수 하여 일반적인 데이터 베이스 연결 작업 에서 발생 할 수 있 는 자원 유출
  • 을 피 할 수 있다.
    3.드 루이 드(드 루이)
  • 데이터 뱅 크 연결 풀 과 장점 을 알 게 되 었 습 니 다.그 다음 에 저 는 여러분 에 게 현재 자주 사용 하 는 데이터 뱅 크 연결 풀 구 조 를 가 져 다 드 리 겠 습 니 다.>드 루이
  • DRUID 는 알 리 바 바 오픈 소스 플랫폼 의 데이터베이스 연결 풀 로 서 C3P 0,DBCP,PROXOOL 등 DB 풀 의 장점 을 결합 하고 로그 모니터링 을 추가 하여 DB 풀 연결 과 SQL 의 실행 상황 을 잘 모니터링 할 수 있 으 며 모니터링 을 위해 생 긴 DB 연결 풀 이 라 고 할 수 있 으 며 현재 가장 좋 은 연결 풀 인
  • 이 라 고 한다.
    3.1 델 루이 의 사용
    아 리 드 루이 연결 탱크 기술 은 먼저 두 단계 로 나 뉜 다.
    1.jar 가방 가입
    druid-1.1.10.jar
    2.코드 단계
    첫 번 째 단계:데이터베이스 연결 탱크 만 들 기
    두 번 째 단계:연결 탱크 의 매개 변 수 를 설정 합 니 다.
    STEP 3:연결 가 져 오기
    델 루이 를 데이터베이스 에 연결 하 는 방법 1
    
    //1、     (      )  
    DruidDataSource ds =new DruidDataSource();
    //2、    
    //(1)      
    ds.setDriverClassName("com.mysql.jdbc.Driver");
    ds.setUrl("jdbc:mysql://localhost:3306/test");
    ds.setUsername("root");
    ds.setPassword("mysql123");
    //3、    
    Connection conn = ds.getConnection();
    //        ,       
    conn.close();
    
    델 루이 로 데이터베이스 연결 하 는 방법 2
    
    //       druid.properties
    url=jdbc:mysql://localhost:3306/0319db ?rewriteBatchedStatements=true
    username=root
    password=123456
    driverClassName=com.mysql.jdbc.Driver
    
        :
    Properties pro = new Properties();
    pro.load(TestDruid2.class.getClassLoader().getResourceAsStream("druid.properties"));
    DataSource ds=
    		DruidDataSourceFactory.createDataSource(pro);
    Connection conn = ds.getConnection();
    
    여기 주의 하 세 요.드 루이 프로필 에 있 는 key 는 제 아래 와 같 아야 합 니 다.그렇지 않 으 면 연결 이 되 지 않 습 니 다.
    
    // druid.properties  
    url=jdbc:mysql://localhost:3306/demo
    username=root
    password=123321
    driverClassName=com.mysql.jdbc.Driver
    4.DBUtils 도구 류
  • 데이터베이스 연결 에 데이터베이스 연결 탱크 가 있어 서 이렇게 편리 하 게 조작 할 수 있다 면 데이터 의 첨삭 과 수정 에 관 한 방법 이 있 습 니까?물론 있 습 니 다.바로 DBUtils
  • 입 니 다.
  • 자주 사용 하 는 데이터 베 이 스 를 조작 하 는 JDBC 의 클래스 와 방법 을 한데 모 은 것 이 바로 DBUtils.
  • 이다.
  • 이것 은 비교적 간단 합 니 다.저 는 자주 사용 하 는 API 조작,구체 적 인 지식 을 소개 하 겠 습 니 다.자바 의 API 문서
  • 을 볼 수 있 습 니 다.
    在这里插入图片描述
    내 가 직접 조작 할 게.여 기 는 내 앞에서 이 루어 진 JDCUtils 류 를 사용 해.게 으 름 피 워..
    
    package com.company.jdbc2;
    
    import com.company.jdbc.JDBCUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    import org.junit.Test;
    
    import java.sql.SQLException;
    import java.util.List;
    
    /*
            DBUtils      , , ,    
     */
    public class DBUtilsDemo {
    
        @Test
        public void test() throws SQLException {
            //1.      
            QueryRunner queryRunner = new QueryRunner();
            //2. , ,      
            /*
                update(Connection conn, String sql, Object param)
                conn :     
                sql : sql  
                param :          
             */
            String sql = "insert into student(sid,sname,sage) values(?,?,?)";
            //    :         
            int i = queryRunner.update(JDBCUtils.getConnection(),
                    sql, 10, "kongkong", 18);
            System.out.println(" " + i + "       ");
        }
    
        @Test
        public void test2() throws SQLException {
            QueryRunner queryRunner = new QueryRunner();
            /*
            query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
            conn :     
            sql : sql  
    
             */
            String sql = "select sid a,sname,sage from student where sid=?";
            //  :               。         sql       
    //        Student student = queryRunner.query(JDBCUtils.getConnection(), sql,
    //                new BeanHandler<Student>(Student.class), 10);
    
    
    
    
            sql = "select sid a,sname,sage from student";
            List<Student> list = queryRunner.query(JDBCUtils.getConnection(), sql,
                    new BeanListHandler<Student>(Student.class));
    
           for (Student s : list) {
               System.out.println(s);
           }
        }
    
    }
    
    일괄 처리 사용
    우리 가 대량의 데이터 조작 을 해 야 할 때 일괄 처리 기술 을 사용 할 수 있 고 간단 하 며 url 에 일괄 처리 파 라 메 터 를 추가 할 수 있 습 니 다.
    
    jdbc:mysql://localhost:3306/Demo?rewriteBatchedStatements=true
    예제 코드,(크 크 크,여전히 내 JDBCutils 가 연결 을 실현 하 는 도구 류...)
    
    package com.company.jdbc3;
    
    import com.company.jdbc.JDBCUtils;
    import org.junit.Test;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    /*
           :
     */
    public class BatchDemo {
    
        /*
                 :
                1.mysql         5.1.3x        
                2. url         
                        jdbc:mysql://localhost:3306/Demo?rewriteBatchedStatements=true
                3.    API:
                    //       
                    ps.addBatch();
                    //     
                    ps.executeBatch();
                    //     
                    ps.clearBatch();
         */
        @Test
        public void test2() throws SQLException {
            //1.       
            Connection connection = JDBCUtils.getConnection();
            //2.   
            PreparedStatement ps = connection.prepareStatement(
                    "insert into student(sid,sname,sage) values(?,?,?)");
            //3.      
            for (int i = 1; i <= 100000 ; i++) {
                ps.setInt(1,i);
                ps.setString(2,"aaa"+i);
                ps.setInt(3,i);
                //       
                ps.addBatch();
    
                if (i % 1000 == 0){
                    //  sql
                    ps.executeBatch();//     
                    //     
                    ps.clearBatch();
                }
    
            }
            //4.   
            JDBCUtils.close(ps,connection);
        }
    
        @Test
        public void test() throws SQLException {
            //1.       
            Connection connection = JDBCUtils.getConnection();
            //2.   
            PreparedStatement ps = connection.prepareStatement(
                    "insert into student(sid,sname,sage) values(?,?,?)");
            //3.      
            for (int i = 1; i <= 100000 ; i++) {
                ps.setInt(1,i);
                ps.setString(2,"aaa"+i);
                ps.setInt(3,i);
                //  sql
                ps.executeUpdate();
            }
            //4.   
            JDBCUtils.close(ps,connection);
        }
    }
    
    
    JDBC 의 확장 지식 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 JDBC 지식 에 관 한 내용 은 예전 의 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 도 많은 응원 부 탁 드 리 겠 습 니 다!

    좋은 웹페이지 즐겨찾기