반응형

미완

 

선생님이 수업시간에 만들 삼광기업? 이라는 임의의 회사 테이블 사진과 데이터 파일을 주셔서 그걸 기반으로 수업시간에 만들어 보았는데 전에 수업전에 만든 JDBC와 VO클래스를 필요할때마다 만드는 점이 달랐던거 같다. 집에서도 복습을 해보고 기존에 만들어놓은 코드들을 안보고 백지상태에서 써보면 뭔가 뿌듯할거 같아서 최대한 참고를 안해보고 복습 해보겠다. 백지가아닌건가 양심적으로 최대한 안보고 작성해보겠다.

 

일단 삼광기업? 의 테이블과 데이터파일들을  올려보겠다.

고객.csv
0.00MB
운송.csv
0.00MB
제품.csv
0.00MB
주문.csv
0.00MB
주문항목.csv
0.00MB
직원.csv
0.00MB

일단 처음으로 만들 클래스는 DB와의 연결을 도와줄 util 클래스부터 만들어보겠다. 

package day12_20;

import java.sql.*;

public class JDBCUtil {
    public static Connection  makeConn(){
        String DRV="org.mariadb.jdbc.Driver";  // 디비연결을 위한 드라이버
        String  URL=""; // aws호스트주소
        String USR=""; 보안상 안적음
        String PWD="";

        Connection conn = null;

        try {
            Class.forName(DRV);  // 드라이버 로드
            conn = DriverManager.getConnection(URL,USR,PWD); // 드라이버 연결
        } catch (ClassNotFoundException e) {
            System.out.println("드라이버에 문제있어 ?");
            e.printStackTrace();
        } catch (SQLException throwables) {
            System.out.println("로그인 실패");
            throwables.printStackTrace();
        }

        return conn;
    }
    // 파괴 메서드
    public static void destroyConn(Connection conn, PreparedStatement pstmt, ResultSet rs) {
        if(conn !=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (pstmt !=null){
            try {
                pstmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(rs !=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    public static void destoryConn(Connection conn, PreparedStatement pstmt){
        if(conn !=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (pstmt !=null){
            try {
                pstmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

 

작성순서는 메인클래스에다 서비스클래스를 인스턴스후 서비스 클래스 안에 있는 디스플레이 메서드를 띄우고 나서 숫자 입력시 정해놓은 메서드가 실행되게 switch문을 작성한다. 이렇게 작성하면 서비스 클래스와 서비스 클래스 내부의 메서드가 생성되어있지 않는 상태여서 오류가 나오면서 빨간줄이 가게될텐데 이때 나는 IDE의 오류해결기능? 을 이용해서 클래스와 메서드를 생성하는데 생각보다 개꿀이다. 오류가난 빨간줄에 빨간전구를 클릭하면 오류 해결대책으로 여러가지 선택지가 있는데 거기서 클래스생성,메서드생성등을 입맛에 골라 선택하면  바로바로 만들어준다 이번에 만들때는 전체적인 틀에서 세부적인 기능을 넘어가게 만들어 보았다. 예를들어 삼광의 전체 테이블중 직원테이블을 관리하고자 인사관리라는 메뉴를 만들고 인사관리 메뉴를 선택하면 그안에 또 세부적인 인사추가 / 인사조회 라던지 이런 메뉴들이 나누어 지도록 일단 머리로 돌렸을때는 switch/case 문 안에다 IF 문을 이용해서 해봤는데 잘된다 

package day12_20;

import java.util.Scanner;

public class SamKwangMain {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        SamKwangService sv = new SamKwangService();
        sv.displaymenu();
        int button = Integer.parseInt(sc.nextLine());

        while(true) {
            switch (button) {
                case 1:
                            sv.employeeMenu();
                            button = Integer.parseInt(sc.nextLine());
                            if (button==1){
                                sv.newEmployee();
                            }else if(button==2){
                                sv.readEmployee();
                            }else if(button==3){
                                sv.readOneEmployee();
                            }else sv.displaymenu();
                    break;
                case 2:

                    break;
                case 3:

                    break;
                case 0:
                    System.exit(0);
                    break;
            }
        }
    }


}

 

이후 서비스 만들어지 서비스 클래스에서 콘솔창에 나올 디스플레이 메뉴 메서드들을 만들고 

newEmployee() 메서드를 이용해 새로운 인사정보를 받는 메서드를 작성하는데 작성하는데 있어 

인사정보의 값들을 DB에 전달해주기 전에 담아둘 그릇이 필요한데 이때 VO클래스를 생성해서 직원테이블을 참조해 직원 테이블에 있는 컬럼값들을 담을 변수들을 선언해준다. 이역시 오류해결기능을 이용하면 번거롭게 다시 프로젝트창에서 클래스 생성을 안해주어도 된다. 개꿀

 

VO클래스 생성해서 생성자와 getter/setter 를 생성해주자 

package day12_20;

public class SamKwangVO {
    private int 인사번호;
    private String 주민등록번호;
    private String 성명;
    private String 소속부서;
    private String 직책;
    private String 인사일;

    public SamKwangVO() {
    }

    public SamKwangVO(int 인사번호, String 주민등록번호, String 성명, String 소속부서, String 직책, String 인사일) {
        this.인사번호 = 인사번호;
        this.주민등록번호 = 주민등록번호;
        this.성명 = 성명;
        this.소속부서 = 소속부서;
        this.직책 = 직책;
        this.인사일 = 인사일;
    }

    public SamKwangVO(int 인사번호, String 성명, String 소속부서, String 직책) {
        this.인사번호 = 인사번호;
        this.성명 = 성명;
        this.소속부서 = 소속부서;
        this.직책 = 직책;
    }

    public int get인사번호() {
        return 인사번호;
    }

    public void set인사번호(int 인사번호) {
        this.인사번호 = 인사번호;
    }

    public String get주민등록번호() {
        return 주민등록번호;
    }

    public void set주민등록번호(String 주민등록번호) {
        this.주민등록번호 = 주민등록번호;
    }

    public String get성명() {
        return 성명;
    }

    public void set성명(String 성명) {
        this.성명 = 성명;
    }

    public String get소속부서() {
        return 소속부서;
    }

    public void set소속부서(String 소속부서) {
        this.소속부서 = 소속부서;
    }

    public String get직책() {
        return 직책;
    }

    public void set직책(String 직책) {
        this.직책 = 직책;
    }

    public String get인사일() {
        return 인사일;
    }

    public void set인사일(String 인사일) {
        this.인사일 = 인사일;
    }
}

 

vo클래스를 작성했으면 다시 service 클래스로 돌아와서 vo클래스를 인스턴스해서 vo클래스의 생성자를 이용하여 입력받은 값들은 vo클래스에 넣어준다.

DB에 값을 전달해주는 DAO클래스의 메서드를 이용하는 코드를 작성하고 이때 매개변수로 아까 위에서 vo클래스를 인스턴스한 객체로 설정해준다.

package day12_20;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Scanner;

public class SamKwangService {

    // 메뉴화면
    public void displaymenu() {
        StringBuilder sb = new StringBuilder();

        sb.append("-----삼광관리프로그램V1-----\n")
        .append("1.인사관리 실행\n")
        .append("2.미정\n")
        .append("3.미정\n")
        .append("0.프로그램종료\n")
                .append("입력 : ");
        System.out.println(sb);
    }
    // 인사관리 화면
    public void employeeMenu() {
        StringBuilder sb = new StringBuilder();
        sb.append("1. 인사정보 추가\n")
                .append("2.인사정보 조회\n")
                .append("3.인사정보 상세조회\n")
                .append("종료시 아무키 (1/2/3/ 제외)\n")
                .append("입력 :");

        System.out.println(sb);
    }

    public void newEmployee() {
        SamKwangVO vo = new SamKwangVO();
        Scanner sc = new Scanner(System.in);
        System.out.print("인사번호 입력 :");
        vo.set인사번호(Integer.parseInt(sc.nextLine()));
        System.out.print("주민등록번호 입력 :");
        vo.set주민등록번호(sc.nextLine());
        System.out.print("성명 입력 :");
        vo.set성명(sc.nextLine());
        System.out.print("소속부서 입력 :");
        vo.set소속부서(sc.nextLine());
        System.out.print("직책 입력 :");
        vo.set직책(sc.nextLine());
        System.out.print("입사일 입력 :");
        vo.set인사일(sc.nextLine());

        String result = SamKwangDAO.insertEMP(vo);

        System.out.println(result);
    }

    public void readEmployee() {
        ArrayList<SamKwangVO> emps = new ArrayList<>();

       emps = SamKwangDAO.readEmp();
       String fmt = "인사번호 :%s 성명 :%s 소속부서 :%s 직책 :%s\n";
       StringBuilder sb = new StringBuilder();
       for(SamKwangVO emp : emps){
           String result = String.format(fmt,emp.get인사번호(),emp.get성명(),emp.get소속부서(),emp.get직책());
           sb.append(result);
       }
        System.out.println(sb.toString());

    }

    public void readOneEmployee() {
    }
}

dd

 

 

아까 위에서 설명했듯이 DAO에 빨간줄이 갈텐데 이때 오류해결기능으로 클래스/메서드 둘다 생성후 DAO클래스로 돌아가서 DB에 연결하는 코드를 작성해준다.

package day12_20;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

public class SamKwangDAO {
    public static String insertEMP(SamKwangVO vo) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        String result = "데이터 입력중..?!";

        conn = SamKwangJDBC.makeConn();
        try {
            pstmt = conn.prepareStatement(SamKwangJDBC.insertEmployee);
            pstmt.setInt(1,vo.get인사번호());
            pstmt.setString(2,vo.get주민등록번호());
            pstmt.setString(3,vo.get성명());
            pstmt.setString(4,vo.get소속부서());
            pstmt.setString(5,vo.get직책());
            pstmt.setString(6,vo.get인사일());
            int cnt = pstmt.executeUpdate();
            if(cnt >0){
                result = "데이터 추가 완료!";
            }
        } catch (SQLException se) {
            se.printStackTrace();
        }
        SamKwangJDBC.destoryConn(conn,pstmt);

        return result;
    }

    public static ArrayList<SamKwangVO> readEmp() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        ArrayList<SamKwangVO> emps = new ArrayList<>();


        conn = SamKwangJDBC.makeConn();
        try {
            pstmt = conn.prepareStatement(SamKwangJDBC.readEMP);
            rs= pstmt.executeQuery();
            while(rs.next()) {
                SamKwangVO emp = new SamKwangVO(rs.getInt(1),
                        rs.getString(2),
                        rs.getString(3),
                        rs.getString(4));
                emps.add(emp);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        SamKwangJDBC.destroyConn(conn,pstmt,rs);

        return emps;
    }
}

 

 

 

 

conn.preparestatement 쪽을 보면 jdbc클래스에 연결되어있는 변수를 가져다 쓰는걸 볼 수 있는데 jdbc 클래스에 db에 동작할 쿼리문을 String 변수를 하나 만들어 거기다 저장해놓았다. 이때 preparedstatement를 이용하면 보안에도 좋고 효율도 좋다고 한다. . 보안은 쿼리문에 입력받을 부분을 '?' 으로 표현해서인거 같고 효율은 좋다고하니 그런갑다 하고있다. 

package day12_20;

public class SamKwangJDBC  extends JDBCUtil{
    public static String insertEmployee =
            "insert into 직원 (인사번호, 주민등록번호, 성명, 소속부서, 직책, 입사일) values ( ?,?,?,?,?,?)";

    public static String readEMP=
            "select 인사번호,성명,소속부서,직책 from 직원";
}

 

 

쓰다보니 졸려서.. 이만줄이겠다 시간날때마다 기능 추가해봐야지 개꿀잼~

반응형
반응형

학원에서 자바와 mysql을 맛보기(?) 식으로 공부를 어느정도 진행되고 오늘 JDBC를 이용해 성적프로그램을 

간단하게 만들어 보았고 혼자 실습(?)하는 느낌으로 사원정보 프로그램을 만들어보려고 한다.

보다가 주옥같은 부분이 있다면 말해주길.. 못알아들을수도 있는건 함정 

 

JDBC ( java database connectivity ) :

자바를 통해 다양하고 관계형 데이터베이스에 접속하고 

SQL문을 실행해서 관리하고자 할때 

사용하는 표준 SQL인터페이스

이것을 통해 데이터베이스 코드를 한번만 작성해두면

어떤 DBMS라도 코드 변경 없이 동일하게 작동시킬 수 있음

JDK에 포함된 JDBC 인터페이스는 java.sql 패키지 아래에 있음 

 

하지만, 이것만으로는 작동하지 않고

JDBC 인터페이스에 맞게 각 데이터베이스 제조사가 

구현한 JDBC 클래스들이 필요한데,

이것을 JDBC 드라이버라고 함. 

 

JDBC드라이버들은 제조사 홈페이지에서 내려받을수 있음. 

mariadb.org

 

 

1. DB 테이블 생성

mariaDB 전용 스크래치 파일을 만들어 간단한 테이블 생성 코드를 작성

create table EmployeeManage (
    empno int  auto_increment, -- 사원번호는 자동증가하게 설정
    fname varchar(255),        -- 미국식 이름으로 설정 ㅋ ㅈㅅ 
    lname varchar(255),
    email varchar(255),		   
    phone varchar(255),		
    hdate varchar(255),		   -- 입사일
    jobid varchar(255),		   -- 직책번호
    sal int,				   -- 연봉
    comm decimal(5,2),		   -- 수당
    mgrid int,				   -- 사수 사원번호
    deptid int,				   -- 부서번호	
    date timestamp default current_timestamp(), -- 데이터 기록날짜/시간
    primary key (empno)		   -- 사원번호를 기본키로 설정
);

2. EmployeeUtil 클래스 만들기

DB를 접속하여 리소스(테이블)에 접근하고 작업이 끝나면 접속해제(?)하는 메서드를 구현 하기 위한 클래스

접속하기 위해서는 각각 맞는 드라이버 파일을 자바폴더에 설치해서 IDE에서 라이브러리 추가해주어야함 

라이브러리 추가

package semiproject12_16;

import javax.xml.transform.Result;
import java.sql.*;

public class EmployeeUtil {

    // DB접속 하기
    public static Connection makeConn(){
        String DRV = "org.mariadb.jdbc.Driver";  //드라이버 내용고정이라서 외워주면 좋음?
        String URL = "";   // AWS RDS를 이용중인데 여기 엔드포인트 주소를 적어줘야함
        				   // “jdbc:Driver 종류://IP:포트번호/DB명”
        String USR = "";   // DB 사용자 계정
        String PWD = "";   // DB 비번 보안상의 이유로 비워놓았다. 
        Connection conn=null;  // 데이터베이스와 연결하는 객체 

        try {
            Class.forName(DRV);   // Class.forName 을 이요해 드라이버 로드 
            conn = DriverManager.getConnection(URL,USR,PWD); //DB접속하기
        } catch (ClassNotFoundException e) {        
            System.out.println("드라이버 접속 오류");
        } catch (SQLException throwables) {
            System.out.println("DB접속 오류");
        }
        return conn;
    }
    // DB연결 해제
    public static void destroyConn(Connection conn, PreparedStatement pstmt, ResultSet rs){
        if (conn != null) try { conn.close(); } catch (SQLException throwables) { }
            if (pstmt != null)  try { pstmt.close(); } catch (SQLException throwables) { }
                if (rs != null)  try { rs.close(); } catch (SQLException throwables) { }
    }
   // DB연결 해제2 (데이터 입력 메서드에서 사용하기위해 추가생성)
   public static void destroyConn(Connection conn, PreparedStatement pstmt ){
        if (conn != null) try { conn.close(); } catch (SQLException throwables) { }
        if (pstmt != null)  try { pstmt.close(); } catch (SQLException throwables) { }
    }



}

3. EmployeeJDBC 클래스 생성 후 EmployeeUtil 클래스 상속받기 

JDBC클래스에서는 MySql 코드를 String 변수를 static 으로 선언하여 저장해두고  

DB에 데이터를 입력하거나 조회하는 메서드 안에서 작업하기 위해 만들어 둔다 

또한 기존에 만들어놓은 Util 클래스에서의 DB접속/해제 기능을 한개의 클래스에서 사용하기 위해 

상속을 해준다. 

 

package semiproject12_16;

public class EmployeeJDBC  extends EmployeeV2Util{
   
   // 데이터입력 하기위한 쿼리문 , 동적쿼리문(PreparedStatement)으로 구현
   public static String insertEmployee =         
            "insert into EmployeeManage  (empno,fname,lname,email,phone,hdate,jobid,sal,comm,mgrid,deptid) values" +
                    "(?,?,?,?,?,?,?,?,?,?,?)";       
    // 사원의 모든 정보 조회 쿼리문
    public static String selectEmployee  =
            "select * from EmployeeManage";
    // 특정사원 정보 조회 쿼리문
    public static String selectOneEmployee =
            "select * from EmployeeManage where empno = ?";
    
}

4. EmployeeVO클래스 생성하기

VO( Value Object):

데이터베이스 테이블 값들을 자바에서 변수로 만들어 놓은것 ?

package semiproject12_16;

public class EmployeeVO {
    private int empno;
    private String fname;
    private String lname;
    private String email;
    private String phone;
    private String hdatd;
    private String jobid;
    private int sal;
    private double comm;
    private int mgrid;
    private int deptid;
    private String date;

    public EmployeeVO() {
    }

    public EmployeeVO(int empno, String fname, String lname, String email, String phone, String hdatd, String jobid, int sal, double comm, int mgrid, int deptid) {
        this.empno = empno;
        this.fname = fname;
        this.lname = lname;
        this.email = email;
        this.phone = phone;
        this.hdatd = hdatd;
        this.jobid = jobid;
        this.sal = sal;
        this.comm = comm;
        this.mgrid = mgrid;
        this.deptid = deptid;
    }

    public EmployeeVO(int empno, String fname, String lname, String email, String phone, String hdatd, String jobid, int sal, double comm, int mgrid, int deptid, String date) {
        this.empno = empno;
        this.fname = fname;
        this.lname = lname;
        this.email = email;
        this.phone = phone;
        this.hdatd = hdatd;
        this.jobid = jobid;
        this.sal = sal;
        this.comm = comm;
        this.mgrid = mgrid;
        this.deptid = deptid;
        this.date = date;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public int getEmpno() {
        return empno;
    }

    public void setEmpno(int empno) {
        this.empno = empno;
    }

    public String getFname() {
        return fname;
    }

    public void setFname(String fname) {
        this.fname = fname;
    }

    public String getLname() {
        return lname;
    }

    public void setLname(String lname) {
        this.lname = lname;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getHdatd() {
        return hdatd;
    }

    public void setHdatd(String hdatd) {
        this.hdatd = hdatd;
    }

    public String getJobid() {
        return jobid;
    }

    public void setJobid(String jobid) {
        this.jobid = jobid;
    }

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public double getComm() {
        return comm;
    }

    public void setComm(double comm) {
        this.comm = comm;
    }

    public int getMgrid() {
        return mgrid;
    }

    public void setMgrid(int mgrid) {
        this.mgrid = mgrid;
    }

    public int getDeptid() {
        return deptid;
    }

    public void setDeptid(int deptid) {
        this.deptid = deptid;
    }
}

 

5. 인터페이스, 제네릭클래스 생성후  데이터입력,조회 메서드를 작성할 서비스 클래스 생성하기.

package semiproject12_16;

import java.sql.*;

public abstract class EmployeeInterface  {

	// 새로운 사원 입력 메서드
	public abstract void newEmployee();
    // 사원조회 메서드
    public abstract void readEmployee();
    // 특정사원 조회 메서드
    public abstract void readOneEmployee();


}
// 제네릭클래스 생성 후 인터페이스 상속
// 생성이유는 인터페이스에서 만들어놓은 메서드들은 재정의? 가 꼭 필요한데 제네릭클래스에서 
// 재정의후 서비스클래스에서 상속을통해 편리하게 필요한 메서드만 가져와 정의를 내릴수 있다
package semiproject12_16;

public abstract class EmployeeGenericClass impelements EmployeeInterface {
    @Override
    public void newEmployee() {

    }

    @Override
    public void readEmployee() {

    }

    @Override
    public void readOneEmployee() {

    }

    @Override
    public void modifyEmployee() {

    }

    @Override
    public void removeEmployee() {

    }
}

6. EmployeeService, EmployeeDAO 클래스 생성하기

package semiproject12_16;

import java.util.ArrayList;
import java.util.Locale;
import java.util.Scanner;

public class EmployeeService extends EmployeeGenericClass{
	
    public void displayMenu(){
        StringBuilder sb = new StringBuilder();
        sb.append("-------------------\n")
                .append("인사정보 처리프로그램 v1\n")
                .append("-------------------\n")
                .append("1. 인사 정보 입력\n")
                .append("2. 인사 정보 조회\n")
                .append("3. 인사 정보 상세조회\n")
                .append("4. 인사 정보 수정\n")
                .append("5. 인사 정보 삭제\n")
                .append("0. 프로그램 종료\n")
                .append("-------------------\n")
                .append("원하시는 작업은 ? [1,2,3,4,5,0] ");
        System.out.print(sb);
    }
	
    // 데이터입력 메서드 
    // DB에 데이터값 넣는메서드는 DAO클래스에서 정의
    @Override
    public void newEmployee() {
        int empno;
        String fname;
        String lname;
        String email;
        String phone;
        String hdatd;
        String jobid;
        int sal;
        double comm;
        int mgrid;
        int deptid;

        Scanner sc = new Scanner(System.in);
        System.out.print("사번을 입력하세요 : ");
        empno = Integer.parseInt(sc.nextLine());
        System.out.print("이름을 입력하세요 : ");
        fname = sc.nextLine();
        System.out.print("성을 입력하세요 : ");
        lname = sc.nextLine();
        System.out.print("이메일을 입력하세요 : ");
        email = sc.nextLine();
        System.out.print("전화번호를 입력하세요 : ");
        phone = sc.nextLine();
        System.out.print("입사일을 입력하세요 : ");
        hdatd = sc.nextLine();
        System.out.print("직책을 입력하세요 : ");
        jobid = sc.nextLine();
        System.out.print("급여를 입력하세요 : ");
        sal = sc.nextInt();
        System.out.print("수당 입력하세요 : ");
        comm = sc.nextInt();
        System.out.print("상사번호를 입력하세요 : ");
        mgrid = sc.nextInt();
        System.out.print("부서번호를 입력하세요 : ");
        deptid = sc.nextInt();

        EmployeeV2VO emp = new EmployeeV2VO(empno,fname,lname,email,phone,hdatd,jobid,sal,comm,mgrid,deptid);
        String result = EmployeeV2DAO.insertEmployee(emp);   // DAO클래스참조
        System.out.println(result);
    }


    // 조회할 성적데이터를 DAO로부터 넘겨받아 출력
    @Override
    public void readEmployee() {
        String fmt = "사원번호 : %s, 성 :%s, 이름 :%s, 이메일 :%s, 전화번호 :%s, 입사일 :%s, 직책 :%s 급여 :%s 수당 :%s, 사수 :%s, 부서번호 :%s, 데이터추가일 :%s\n";
        StringBuilder sb = new StringBuilder();

        ArrayList<EmployeeV2VO> emps = EmployeeV2DAO.selectEmployee();

        for(EmployeeV2VO emp : emps){
            String result = String.format(fmt,emp.getEmpno(),emp.getFname(),emp.getLname(),emp.getEmail(),emp.getPhone(),emp.getHdatd(),emp.getJobid(),emp.getSal(),
                    emp.getComm(),emp.getMgrid(),emp.getDeptid(),emp.getDate());
            sb.append(result);
        }
        System.out.println(sb.toString());
    }
	
    // 특정사원 정보 출력
    @Override
    public void readOneEmployee() {
        String fmt = "사원번호 : %s, 성 :%s, 이름 :%s, 이메일 :%s, 전화번호 :%s, 입사일 :%s, 직책 :%s, 급여 :%s 수당 :%s, 사수 :%s, 부서번호 :%s, 데이터추가일 :%s\n";
        Scanner sc = new Scanner(System.in);
        System.out.print("조회할 사원의 사원번호는 ? :");
        String empno = sc.nextLine();
		
        // DAO클래스에 위에서 받은 조회할사원번호를 매개변수로 보내주기
        EmployeeV2VO emp = EmployeeV2DAO.selectOneEmployee(empno);
		
        // DAO클래스의 메서드로 받아온 값들을 출력
        String result = String.format(fmt,emp.getEmpno(),emp.getFname(),emp.getLname(),emp.getEmail(),emp.getPhone(),emp.getHdatd(),emp.getJobid(),emp.getSal(),
                emp.getComm(),emp.getMgrid(),emp.getDeptid(),emp.getDate());
        System.out.println(result.toString());
    }
}
package semiproject12_16;

import stillgood96.SungJukJDBC;

import java.sql.*;
import java.util.ArrayList;

public class EmployeeDAO {
	// EmployeeService에서 입력받은 데이터값들을 매개변수로 받는 메서드로 생성
    public static String insertEmployee(EmployeeV2VO emp) {
        // 연결객체 생성
        Connection conn = null;
        // DB쿼리문 실행하기위한 객체 생성
        PreparedStatement pstmt = null;
        // 데이터의 입력 유/무 알리기위한 result변수 선언
        String result = null;
		
        // JDBC(util을상속받음)에 상속받은 util의 makeConn 메서드이용해서 드라이버 로드 및 DB접속
        conn = EmployeeV2JDBC.makeConn();
        try {
        	// JDBC에 작성한 데이터입력 쿼리문 가져오기 
            pstmt = conn.prepareStatement(EmployeeV2JDBC.insertEmployee);
            // 서비스클래스에서 매개변수로 받아온 데이터값을 넣기
            pstmt.setInt(1,emp.getEmpno());
            pstmt.setString(2,emp.getFname());
            pstmt.setString(3,emp.getLname());
            pstmt.setString(4,emp.getEmail());
            pstmt.setString(5,emp.getPhone());
            pstmt.setString(6,emp.getHdatd());
            pstmt.setString(7,emp.getJobid());
            pstmt.setInt(8,emp.getSal());
            pstmt.setDouble(9,emp.getComm());
            pstmt.setInt(10,emp.getMgrid());
            pstmt.setInt(11,emp.getDeptid());
            int cnt = pstmt.executeUpdate();
            if (cnt>0)
                result = "성적데이터 저장완료!";
        } catch (SQLException throwables) {
            System.out.println("DB 데이터 추가완료!");
        }
        EmployeeV2JDBC.destroyConn(conn,pstmt);
        return result;
    }

    // 사원정보들을 동적배열에 저장해서 넘긴다.
    public static ArrayList<EmployeeV2VO> selectEmployee() {
        ArrayList<EmployeeV2VO> emps = new ArrayList<>();
        Connection conn = null;
        PreparedStatement pstmt = null;
        // ResultSet 
        // select(조회)의 결과를 저장하는 객체
        ResultSet rs = null;

        conn = EmployeeV2JDBC.makeConn();
        try {
            pstmt = conn.prepareStatement(EmployeeV2JDBC.selectEmployee);
            rs = pstmt.executeQuery();
           // 반복문으로 모든 데이터를 가져오게 설정
           while(rs.next()){
                EmployeeV2VO emp= new EmployeeV2VO(
                        rs.getInt(1),
                        rs.getString(2),
                        rs.getString(3),
                        rs.getString(4),
                        rs.getString(5),
                        rs.getString(6),
                        rs.getString(7),
                        rs.getInt(8),
                        rs.getDouble(9),
                        rs.getInt(10),
                        rs.getInt(11),
                        rs.getString(12) );
                emps.add(emp);   // 행을 다읽어올때마다 동적배열에 저장후 다시 그다음행 읽어오기
            }
        } catch (SQLException throwables) {
            System.out.println("selectEmployee 에서 오류 발생");
        }
        EmployeeV2JDBC.destroyConn(conn,pstmt,rs);

        return emps;
    }
	
    // 특정사원 정보 긁어오기
    // 서비스에서 받아온 특정사원번호를 매개변수로 받는 메서드로 생성
    public static EmployeeV2VO selectOneEmployee(String empno) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        EmployeeV2VO emp = null;
        ResultSet rs = null;

        conn = EmployeeV2JDBC.makeConn();

        try {
            pstmt = conn.prepareStatement(EmployeeV2JDBC.selectOneEmployee);
            pstmt.setString(1,empno);
            rs= pstmt.executeQuery();
            // 한개의 값만 가져오면 되니까 if문
            if(rs.next()){
                emp = new EmployeeV2VO(
                        rs.getInt(1),
                        rs.getString(2),
                        rs.getString(3),
                        rs.getString(4),
                        rs.getString(5),
                        rs.getString(6),
                        rs.getString(7),
                        rs.getInt(8),
                        rs.getDouble(9),
                        rs.getInt(10),
                        rs.getInt(11),
                        rs.getString(12)
                );
            }
        } catch (SQLException throwables) {
            System.out.println("selectOneSungJuk 에서 오류발생!");
            throwables.printStackTrace();
        }
        SungJukJDBC.destroyConn(conn,pstmt,rs);

        return emp;
    }
}

  결과출력

결과출력창을 다시보니 

조회할때 테이블처럼 나오도록 양식 변경하면 좋을 것 같고 

수업시간에 mysql 하다가 꽤 오랜시간 후에 다시 자바를 하는거여서 낯설기도 하고 

새로운 부분을 타이트한 일정때문인지 훅훅 지나가서 묻지마 코딩으로 선생님 코딩을 옮겨쓰고 있었는데 

이렇게 블로그에 정리하면서 코드들을 다시 봐보니 이해가 어느정도 간다 과연 백지상태에서 이렇게 다시 쓸수있을까 

반응형
반응형

오랜만에 MySql 에서 벗어나 Java로 다시 돌아와 예외처리부분을 배웠다. 

오랜만에 본 JAVA 코드는 낯설었지만 금새 다시 익숙해졌다 .

수업커리큘럼이 타이트한 탓인지 선생님이 진도가 빠르게 진행되어서 이해보단

선생님의 코드를 따라 쓰는데 급급했던 것 같다. 

그래서 수업이 끝나고 따로 시간을 내서 유튜브로 생활코딩 '자바예외처리' 강의를 듣고 코딩을 따라 쓰고 

내용을 정리해보았다. 같은 파트를 다른 영상으로 같은 내용이지만 다른 설명으로 2회차를 들으니 갈피가 서는 느낌이 

많이 들어서 지루하지 않고 나름 재밌게 잘들었다. 

package day12_14;

public class ExceptionApp {
//1
    // 자바에서는 0을 나눌수 없다 그래서 오류가 뜬다.
// 허나 어떤 프로그램은 24시간 돌아가야한다면
// 이런 오류를 만나 프로그램이 작동이 안하면 난감할 것이다.
// 이럴때 예외처리를 통해 오류가 발생하여도 그다음 프로그램이 작동하게
// 하는 것도 예외처리의 한 방법이 될 수 있다

//2
// 아래를 보면 알수있듯이 2를0으로 나누면 자바에서는 오류가 나오는데(ArithmeticException)
    // 이럴때 예외처리인 try /catch문으로 감싸면 오류를 예외처리로 처리하고
    // catch문을 작성할때 오류에 맞는 예외처리를 넣는것이 좋다. 그리고
    // 안에 있는 코드를 실행후 그다음 코드가 실행되는 것을 볼 수 있다.

    //3
    // 하나의 try문의 예외처리할 문장을 여러개 넣는다면
    // 첫번째 예외처리문을 만났을때 catch문을 실행후
    // 바로 try/catch문을 빠져나간다. 그 다음 예외처리할 문장이
    // 실행조차 안되는 것 같다.



    public static void main(String[] args) {
        //1
        System.out.println(1);
        try {
            System.out.println(2 / 0);  // ArithmeticException
        }catch(ArithmeticException e){
            System.out.println("잘못된 계산이네요");
        }
        System.out.println(3);
        System.out.println(4);


        //2
        int [] scores = {10,20,30};    // 배열의 저장범위 바깥 데이터를 가져오려 할 때
        try {
            System.out.println(scores[3]); // ArrayIndexOutOfBoundsException
        }catch(ArrayIndexOutOfBoundsException aiob){
            System.out.println("없는 값을 찾고 계시네요~ ^^");
        }

        //3
        try {
            System.out.println(10);
            System.out.println(2 / 0);
            int[] scores2 = {10, 20, 30};
        }catch(ArithmeticException e2){
            System.out.println("헛짓거리하시네 ~");
        }catch(ArrayIndexOutOfBoundsException ad){
            System.out.println("그러게말여~");
        }
        System.out.println(15);


    }
}

 

package day12_14;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class CheckedExceptionApp {
    // IOException 을 발생시키는 코드를 발생해 보겠다
    // Checked exception vs unchecked exception
    // 전자의 경우 대표적으로 IOException이 있다.
    // 전자의 경우 컴파일러에서 직접 예외처리를 했는지 검사하기 때문에
    // 반드시 코드에서 예외 처리를 해주어야 한다.

    // 후자의 경우
    // 앞선 'Exception' 클래스에서 볼 수 있었던
    // ArrayIndexOutOfBoundsException 나 ArithmeticException 와 같은 경우로
    // 이와같은 예외처리는 따로 안해도 실행이 가능하지만
    // 실행후 오류메세지가 나온는 것을 확인할 수 있다.

    // 결과적으로 전자인 checked exception 같은 경우는 예외처리를 코드에서 무조건 해주어야하고
    // 후자인 unchecked exception 은 코드 안에서 예외처리를 꼭 안해도 된다는 것
    // 또한 이 두가지로 예외처리가 나뉜다는 정도를 알면 좋을 것 같다고 한다 생활코딩 따거께서

    public static void main(String[] args) {

        try {
            FileWriter f = null;
            f = new FileWriter("data.txt");
            f.write("hello");
            f.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
package day12_14;

import java.io.FileWriter;
import java.io.IOException;

public class Finally_and_Resource {
    // finally 와 resource
    // 자바가 외부 프로그램에 엑세스 할때 생길수 있는 예외처리
    // 대표적인 외부프로그램(리소스)으로는 파일, 네트워크, 데이터베이스가 있다.
    // 다시, 리소스는 자바 내부의 데이터가 아니기에 예외처리가 많이 발생할 수 있다.
    // 자바에서 리소스를 사용할때 자바는 리소스를 붙잡는 모종의 행위(?) 들이 있는데
    // 파일은 나만 파일을 쓰겠어 .. ? 네트워크는 커넥션.. ? 아무튼 붙잡는 작업을 다하고
    // 나면 리소스를 놔줘야하는데 놔주는 코드가 close() 이다.
    // close()를 써주기 위해서는 다소 복잡한 과정이 있다.


    // 일차적으로 아래에서 filewriter를 쓸때 예외가 발생할 수 있어 try/catch문으로 감싸고
    // try문에 close를 쓴다면 try문에서의 예외처리가 발생한다면 close는 실행이 되지 않는다.
    // 그렇기에 필요한것은 finally문안에다 close를 써주는 것인데 finally 문은 예외처리가 발생하건 안하건
    // 무조건 finally문 안에 있는 내용을 실행시켜주는 것인데 그렇기에 finally 문안에 넣으면 빨간밑줄이 기다리고 있을터인데
    // finally를 열고 close문을 쓰면 close가 try문안에서의 지역변수를 받을 수 없어 try문 밖에서 전역변수로 선언을 해야 오류가
    // 안나온다. 그렇게 밖에다 또 선언하고 나면 또 빨간줄이 나오는 것을 확인할 수있는데 ~ 이번에는 또 finally 안에서 close를
    // 실행하는데 있어서도 예외처리가 나올 수 있다는 것이다. 말은 그렇다 . 그래서 finally 안에서 또 예외처리를 해주어야 한다.
    // finally 문 안에서도 예외처리를 또 해주면 비로소 빨간 밑줄을 안보게 될 수 있는데 이와 같은 방법은 너무 복잡하고 장황하다 .
    // 이와 같은 방법을 해결하기 위해 try-with-resource 라는 신기술이 있다고 한다.

    // try-with-resource
    // java7 부터 추가함
    // 위에서 봤듯이 위의 방법은 코드가 매우 장황해진다.
    // 간단히 쓰는 방법을 사용하면
    // 일단 try (close가 필요한 코드) {} catch{} 문
    // 이런식으로 써놓으면 알아서 실행후 예외가 발생하건 안하건 마지막에 close를 실행해준다.
    // 확연히 위와 간단해진 코드를 확인할 수 있다 .


    public static void main(String[] args) {
        FileWriter fw=null;
        try {
             fw = new FileWriter("data2.dat");
            fw.write("hello");
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            // 만약에 fw가 null이 아니라면 close를 해라 ~
            if(fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



        // try-with-resource
        // try with resource statements
        try (FileWriter f = new FileWriter("data.txt")){  // try 괄호 안에다가 close가 필요한클래스를 인스턴스하는 코드 입력
            f.write("HELLO");
            }catch(IOException e){
                e.printStackTrace();
        }




    }
}
반응형
반응형

2020/10/21/ 학원 선행학습 수업 1일차 14:00~18:00

학원에서 한 내용들을 집에서 복습하고자 수업내용의 순서를 나열해보고 그에 따른 느낀점,결과 등을 써보았다.

또한 추후 수업의 커리큘럼이 끝난 후 내가 어떤 내용을 학습했는지 명확하게 구분하기 위함도 있다.

 


1교시

 

프로그래밍:

컴퓨터에게 일을 하도록 명령어를 만드는 것

컴파일:

프로그램 언어를 컴퓨터가 알 수 있는 언어로 바꿔 주는 일

컴파일러:

기계어를 번역해주는 프로그램

자바를 설치하면 자바 컴파일러도 설치됨

자바:

객체지향 언어이기에 유지보수가 쉽고 확장성이 좋다. /

+풍부한 기능을 제공하는 오픈소스 이다. + 안정적이다.

bit(비트):컴퓨터가 표현하는 데이터의 최소 단위 ex) 1byte = 8bits

변수(veriable)의 선언과 초기화

int level; level 이라는 이름의 변수 선언

int level = 0; level 변수 선언과 동시에 0으로 초기화

int lelvel; int의 역할: level 변수의 데이터 타입을 정의

level=10; int의 의미 : level 은 정수이며 4바이트의 데이터 사용

변수의 이름은 숫자로 시작할 수 없고, 키워드도 변수의 이름으로 사용할 수 없다. # 키워드?

+ 이름 사이에 공백이 있을 수 없다. ex) 써야한다면 ' _ ' 언더바 사용

+ 변수의 이름을 정할때는 변수의 역활에 어울리는 의미있는 이름을 사용하자.


2교시

www.oracle.com/kr/downloads/ 들어가서 java(jdk)for developers 다운.

+jre 설치 Jdk 같은경우 최신버전을 jre 같은경우 java se8 에서 찾아볼것

  정수형 문자형 실수형  논거형
1byte=8bits byte - - boolean(참/거)
2bytes=16bits short char double -
4bytes=32bits int - - -
8bytes=64bits long - float -

3교시

www.eclipse.org/downloads/ 이클립스 다운로드

이클립스 설치시 Eclipse IDE for Enterprise Java Developers 로 다운로드

(설치프로그램 실행하면 설치 할수있는 종류가 나오는데 그중에 있음)

byte: 1바이트 단위의 자료형으로 동영상, 음악파일 등 실행파일에 많이 사용

short: 2바이트 단위 c/ c++ 언어에서 많이 사용

int : 자바에서 사용하는 정수에 대한 기본 자료

32비트를 초과해야하는 숫자는long으로

long: 8바이트 자료형

나머지는 ppt가 빨리넘어가서 못적음


4교시

1.windows-고급시스템 설정 보기-고급-환경변수

2.시스템새로만들기-jdk파일 설치위치 변수값 적용- 변수이름은 JAVA_HOME(임의로설정가능)

3.시스템새로만들기-변수이름:classpath 변수값 :%JAVA_HOME(위의 임의의 값으로 써야함)\lib

4.path의 시스템이름 편집- %JAVA_HOME%\bin 새로만들기

5.실행창-cmd-'javac' 입력 자바가 잘 설치되었는지 확인

6.java -version (버전확인)

4교시의 내용중에 windows 에서 설정을 해준부분은 왜 해야하는지 이유는 잘모르겠으나 하라고하니 했는데

이유를 알고 싶다. jdk 파일위치에 왜 변수값을 적용해야 하는지 classpath라는 시스템을 왜 새로만들어야 하는지

반응형

+ Recent posts