ERD 구성
로직 프로세스
주제 선정 이유
MySQL
● MySQL에서 먼저 테이블을 구성한다. 자바에서 구성한것들을 여기서 받아서
데이터베이스에 저장한다.
create database project;
use project;
create table user(
userid varchar(300) primary key,
userpw varchar(300) not null,
username varchar(300) not null,
userphone varchar(300)not null,
useraddr varchar(2000)not null
);
create table car(
carnum varchar(300) primary key,
cartype varchar(300) not null,
distance varchar(300) not null,
carage varchar(300),
price varchar(300) not null,
userid varchar(300),
constraint id_fk foreign key(userid) references user(userid)
);
/* 거래상태 테이블 */
create table dealinfo(
tradenum int primary key auto_increment,
tradestatus varchar(300) not null default "거래대기",
registtime datetime default current_timestamp,
carnum varchar(300),
constraint carnum_fk foreign key(carnum) references car(carnum),
userid varchar(300),
constraint id2_fk foreign key(userid) references user(userid)
);
/* 찜하기 테이블*/
create table wish_list(
dib_num int primary key auto_increment,
/* datetime default current_timestamp 하면 입력할 필요 없이 자동으로 현재시간등록*/
dib_car varchar(300),
dib_userid varchar(300),
dib_time datetime default current_timestamp,
userid varchar(300),
constraint did_fk foreign key(userid) references user(userid)
);
/* 거래후기 테이블 */
create table review(
article_number int primary key auto_increment,
title varchar(300) not null,
detail varchar(4000) not null,
registtime datetime default current_timestamp,
carnum varchar(300),
constraint carnum2_fk foreign key(carnum) references car(carnum),
userid varchar(300),
constraint id4_fk foreign key(userid) references user(userid)
);
/* 쪽지 테이블 */
create table message(
msgnum int primary key auto_increment,
send_id varchar(300) not null,
msg varchar(300) not null,
registtime datetime default current_timestamp,
recieve_id varchar(300) not null,
constraint message_fk foreign key(recieve_id) references user(userid)
);Java 구성
● MySQL에서 받아올 수 있는 것들을 구성했으니 이클립스를 구성해보자DBConnection 생성
● dao패키징에 생성
● MySQL과 연결하기 위해서 필수적으로 있어야 한다! package dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class DBConnection {
private static Connection conn;
public static Connection getConnection() {
// 싱글톤 패턴 : 단 하나의 객체만 만들어서 사용하도록 설계된 패턴
if(conn == null) {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
System.out.println("드라이버 로딩 성공!");
// 다리를 짓고자 하는 목적지
// 맨뒤에 project는 MySQL에서 이클립스와 연동할
// database이름이다. 다른 database면 다른 이름을
// 써줘야 한다.
String url = "jdbc:mysql://localhost:3306/project";
String user = "root";
String password = "1234";
conn = DriverManager.getConnection(url, user, password);
} catch (ClassNotFoundException cnfe) {
System.out.println("드라이버 로딩 실패 : " + cnfe);
} catch(SQLException sqle) {
System.out.println("DB 연결 실패 : " + sqle);
}
}
return conn;
}
}Index 클래스
● view패키지에서 생성
● 시작하는 페이지 package view;
import java.util.Scanner;
//index : 시작하는 페이지
public class Index {
public static void main(String[] args) {
System.out.println("★☆★☆★☆다솔Car★☆★☆★☆");
System.out.println("환영합니다!!!");
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("1. 회원가입\n2. 로그인 \n3. 나가기");
int choice = sc.nextInt();
// Controller
if(choice == 3) {
System.out.println("안녕히가세요");
// 강제종료
// 정상적인 종료
System.exit(0);
}
switch(choice) {
case 1:
// 회원가입
// JoinView 클래스 생성
new JoinView();
break;
case 2:
// 로그인
// LoginView 클래스 생성
new LoginView();
break;
default:
System.out.println("다시 입력하세요");
}
}
}
}→ 1을 입력받으면 회원가입할 수 있는 클래스를 생성자로 불러온다.
→ 2를 입력받으면 로그인할 수 있는 클래스를 생성자로 불러온다.JoinView 클래스
● view패키지에서 생성
● 회원가입 클래스이다.
● 생성자로 불러올 수 있게 생성자안에 코드를 작성하자!
○ 생성자로 불러오는 이유:
■ 단지 불러오는 용도로 사용할꺼고 여기에서 생성할게 회원가입을
위해 작성하는거기 때문에 생성자로 만들어서 불러오자!
앞으로 view에서 만들 클래스도 같은 형식이기 때문에 설명은 여기서만 한다.
public class JoinView {
// Index 클래스에서 회원가입을 위한 생성자 생성
public JoinView() {
Scanner sc = new Scanner(System.in);
//새로 가입할 "회원의 정보들" 을 데이터베이스에 저장해야 하므로
//기능을 구현해 놓은 DAO가 필요하고, 회원 관련된 데이터이므로
//UserDAO를 사용해야 한다.
UserDAO udao = new UserDAO();
UserDTO udto = new UserDTO();
boolean condition = false;
while(true) {
System.out.print("아이디 : ");
String userid = sc.next();
// 중복 검사
if(udao.checkDup(userid)) {
System.out.println("사용 가능한 아이디 입니다");
System.out.println("비밀번호 : (조건: 대문자,소문자,숫자,특문 포함하여 8글자 ~ 20글자)");
// sc = new Scanner(System.in);
String userpw = sc.next();
if(checkpw2(userpw)){
System.out.println("가능한 비밀번호 입니다.");
} else {
System.out.println("불가능한 비밀번호 입니다.");
break;
}
System.out.print("이름 : ");
String username = sc.next();
System.out.print("핸드폰 번호 : ");
String userphone = sc.next();
condition = false;
for (int i = 0; i < userphone.length() ; i++) {
// System.out.println(userphone.charAt(i));
// 대문자 확인(아스키 코드)
char ch = userphone.charAt(i);
if(ch <= 90 && ch >= 65) {
// 대문자에 포함되면 false
condition = false;
System.out.println("대문자는 사용할 수 없습니다.");
// 그리고 나가짐
break;
// 대문자를 통과하면 소문자 검사!
} else if(ch >= 97 && ch <= 122) {
// 소문자면 false
condition = false;
System.out.println("소문자는 사용할 수 없습니다.");
// 인덱스로 가진다.
Index.main(null);
break;
// 특문 있나 확인후 있으면 false
} else if(ch >= 33 && ch <= 47) {
condition = false;
System.out.println("특수문자는 사용할 수 없습니다.");
// 인덱스로 가진다.
Index.main(null);
break;
} if(ch == 0) {
condition = false;
System.out.println("NUL이라 안됩니다.");
// 인덱스로 가진다.
Index.main(null);
break;
} if(ch >= '0' && ch <= '9') {
condition = true;
}
}
// condition = true;
// 숫자가 11개 면서 condition이 true이면 통과
if(userphone.length() ==11 && condition == true) {
System.out.println("정상적으로 입력되었습니다.");
// UserDTO에 있는 메소드에 입력
udto.setUserphone(userphone);
// condition이 false면
} else if(!condition) {
System.out.println("숫자만 입력하세요");
// 핸드폰 번호가 11가 아니면
} else if(userphone.length() != 11) {
System.out.println("전화번호는 11자리 입니다.");
} else {
System.out.println("오류가 발생했습니다.");
}
System.out.print("주소 : ");
sc = new Scanner(System.in);
String useraddr = sc.nextLine();
//여기까지 왔다면 회원 가입에 필요한 모든 정보를 입력받았다는
//뜻이므로, UserTable에 이 모든 데이터들을 저장해 주어야 한다.
//저장하는 기능적인 코드들은 View에서 구현하는 것이 아니고
//udao에 구현해 놓고 메소드를 호출하는 식으로 사용한다.
//호출시 넘겨주어야 할 데이터들이 총 6개나 되므로 UserDTO 타입의
//객체 하나로 포장해서 그 객체를 매개변수에 넘겨준다.
UserDTO user = new UserDTO(userid, userpw, username, userphone, useraddr);
//위에서 포장된 DTO 객체를 넘겨준다.
// user을 UserDAO에 넘겨준다.
if(udao.join(user)) {
System.out.println("회원가입 성공!");
System.out.println(username+"님 가입을 환영합니다!");
new LoginView();
}
else {
System.out.println("회원가입 실패 / 다시 시도해 주세요.");
break;
}
} else {
System.out.println("중복된 아이디가 있습니다. 다시 시도해 주세요.");
break;
}
}
}
// 소문자, 대문자, 0~9 숫자, 특수문자 8자리 이상!(소문자, 대문자 같이 안써도 됨!)
// 위에서 비밀번호를 생성하기위한 조건을 주기위해서 메소드 만들었다!
public boolean checkpw2(String userpw) {
String passwordPolicy = "^(?=.*[A-Za-z])(?=.*[0-9])(?=.*[$@$!%*#?&])[A-Za-z[0-9]$@$!%*#?&]{8,20}$";
Pattern pattern_pwd = Pattern.compile(passwordPolicy);
Matcher matcher_pwd = pattern_pwd.matcher(userpw);
return matcher_pwd.matches();
}
} ① if(udao.checkDup(userid)) { 이거는 회원가입할 때 아이디가 기존에 있는
아이디인지 확인하기 위해서 UserDAO에서 기능을 구현했다.
▼ // JoinView클래스에 있는 중복검사 메소드 기능 구현
public boolean checkDup(String userid) {
String sql = "select * from user where userid=?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, userid);
rs = ps.executeQuery();
// 회원가입 전에 검사하는 거니까
// 중복된게 없어야 true가 되야므로 !rs.next 리턴
return !rs.next();
} catch (SQLException sqle) {
System.out.println("checkDup 수행 실패! : " + sqle);
}
return false;
} ② if(checkpw2(userpw)){ 이거는 회원가입할 때 비밀번호에 조건을 주기
위해서 하단부분에 메소드를 만들어서 사용했다.
UserDTO 생성
● DAO에 포장된 객체들을 보내주기 위해서 DTO를 생성해줬다. package dto;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class UserDTO {
//Alt + Shift + A : 그리드 편집 모드(여러줄 동시에 편집)
private String userid;
private String userpw;
private String username;
private String userphone;
private String useraddr;
public UserDTO() {
this.userid = "";
this.userpw = "";
this.username = "";
this.userphone = "";
this.useraddr = "";
}
public UserDTO(String userid, String userpw, String username, String userphone, String useraddr) {
this.userid = userid;
this.userpw = userpw;
this.username = username;
this.userphone = userphone;
this.useraddr = useraddr;
}
public String getUserid() {
return userid;
}
public void setUserid(String userid) {
this.userid = userid;
}
public String getUserpw() {
return userpw;
}
public void setUserpw(String userpw) {
this.userpw = userpw;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getUserphone() {
return userphone;
}
public void setUserphone(String userphone) {
this.userphone = userphone;
}
public String getUseraddr() {
return useraddr;
}
public void setUseraddr(String useraddr) {
this.useraddr = useraddr;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof UserDTO) {
UserDTO target = (UserDTO)obj;
if(target.userid.equals(this.userid)) {
return true;
}
}
return false;
}
@Override
public String toString() {
//apple abcd1234 김사과 10 01012341234 서울시 강남구 역삼동
return userid+"\t"+userpw+"\t"+username+
"\t"+userphone+"\t"+useraddr;
}
// String 타입 hashCode 사용하기
public boolean hashCode(Object obj) {
UserDTO anotherobj = (UserDTO)obj;
return (this.userid.equals(anotherobj.userid));
}
}LoginView
● view 패키지에서 생성 package view;
import java.util.Scanner;
import dao.UserDAO;
import dto.UserDTO;
public class LoginView {
// Index 클래스에서 생성자를 불러오기 위해서 생성자 생성
public LoginView() {
Scanner sc = new Scanner(System.in);
UserDAO udao = new UserDAO();
System.out.print("아이디 : ");
String userid = sc.next();
System.out.print("비밀번호 : ");
String userpw = sc.next();
// UserDAO에 userid, userpw을 매개변수로 넘겨준다.
if(udao.login(userid,userpw)) {
System.out.println(userid+"님 어서오세요~");
//메인창 띄우기
new MainView();
}
else {
System.out.println("로그인 실패 / 다시 시도해 주세요.");
new LoginView();
}
}
}→ 아이디하고 비밀번호를 입력받고 DAO에 넘겨준다음 환영인사가 나오고
MainView로 가진다.
▼ // LoginView에서 매개변수를 받아와서 로그인 기능 구현
public boolean login(String userid, String userpw) {
String sql = "select * from user where userid =? and userpw=?";
try {
ps =conn.prepareStatement(sql);
ps.setString(1, userid);
ps.setString(2, userpw);
rs = ps.executeQuery();
if(rs.next()) {
// Session 클래스에 hashmap으로 아이디 데이터 기록해서
// put으로 저장하고 get으로 가져올 수 있게 구성
Session.put("login_id", userid);
return true;
}
} catch (SQLException sqle) {
System.out.println("login 수행 실패! : " + sqle);
}
return false;
}MainView 클래스 생성
● view 패키지에서 클래스 생성
● 여기에 회원정보, 차량검색, 커뮤니티, 내 정보수정, 로그아웃 기능이 있다. package view;
import java.util.Scanner;
import dao.Session;
public class MainView {
public MainView() {
Scanner sc = new Scanner(System.in);
while(true) {
//우리가 만든 프로젝트는 무조건 main()부터 시작하는 프로그램이다.
//즉 진입점이 한개이기 때문에 아래와 같은 코드를 생략 가능하다.
//*웹 상이나 다른 프로그램에서는 진입점이 여러개일 수 있으므로
//아래처럼 로그인 되어있는지를 먼저 검사해주는것이 필요하다.
// 여기서 null이면 로그인중인게 아니므로 break되서 나가진다.
if(Session.get("login_id") == null) {
System.out.println("로그인 후 이용하세요");
break;
}
System.out.println("=========="+Session.get("login_id")+"님 환영합니다==========\n"
+ "1. 회원정보\n2. 차량검색\n3. 커뮤니티\n"
+ "4. 내 정보수정\n5. 로그아웃");
int choice = sc.nextInt();
if(choice == 5) {
//로그아웃
System.out.println(Session.get("login_id")+"님 안녕히가세요~");
//로그인한 정보를 담아주는 Session에서 login_id라는 KEY 와 쌍을 이루고 있는 값은
//로그아웃을 했다면 없애주어야 한다. 따라서 null로 초기화 해주어야 한다.
Session.put("login_id", null);
break;
}
switch (choice) {
//회원정보
case 1:
new MyinfoView();
break;
//차량검색
case 2:
new Car_Search();
break;
//커뮤니티(구매후기, 쪽지기능, 구매후기)
case 3:
new Review();
break;
//내 정보수정
case 4:
new Modify_Myinfo();
break;
default:
System.out.println("입력실패!!");
break;
}
}
}
}MyinfoView
● 내정보 보는 곳
● 찜한것도 볼 수 있다.
package view;
import java.util.Scanner;
import dao.CarDAO;
import dao.UserDAO;
public class MyinfoView {
public MyinfoView() {
Scanner sc = new Scanner(System.in);
UserDAO udao = new UserDAO();
System.out.println("1. 회원정보 확인 \n2. 찜한 목록 보기 \n3. 뒤로가기");
int choice = sc.nextInt();
if(choice == 1) {
System.out.print("비밀번호 재입력 : ");
String userpw = sc.next();
if(udao.checkpw(userpw)) {
System.out.println("============ 회원 정보 보는 곳===========");
System.out.println(udao.myInfo());
} else {
System.out.println("정보를 확인할 수 없습니다.");
}
} else if(choice ==2) {
System.out.println("찜하기 목록을 불러옵니다~");
System.out.println(udao.viewDib());
} else if(choice == 3) {
System.out.println("메인뷰로 돌아갑니다!");
new MainView();
}
}
}① 여기서는 회원정보 확인, 찜한 목록을 볼 수 있다.
→ 회원정보를 보려고 하면 비밀번호를 재입력을 해야하고
그것을 if(udao.checkpw(userpw)) {가 체크한다.
▼ // 비밀번호를 재입력받는 거기 때문에 기존에 비밀번호가 있어야 한다.
public boolean checkpw(String userpw) {
String sql = "select * from user where userpw=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, userpw);
rs = ps.executeQuery();
// 비밀번호를 체크하는거니까 기존에 있어야 true
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkpw 수행 실패! : " + sqle);
}
return false;
}② 2번을 눌르면 찜하기 목록을 불러오는 곳으로 간다. public String viewDib() {
String sql = "select * from wish_list where userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
rs = ps.executeQuery();
if(rs.next()) {
String car = rs.getString("dib_car");
String id = rs.getString("dib_userid");
return "\n\t찜한 차종 : " + car + "\n\t찜한 아이디 : " + id;
}
// } catch(NullPointerException sqle) {
// System.out.println("null에러 잡자");
}
catch (SQLException sqle) {
System.out.println("viewDib 수행 실패! : " + sqle);
}
return "찜한 목록이 없네요";
}Car_Search
▼ package view;
import java.util.Scanner;
import dao.CarDAO;
import dto.CarDTO;
public class Car_Search {
public Car_Search() {
Scanner sc = new Scanner(System.in);
CarDAO cdao = new CarDAO();
boolean condition = false;
CarDTO cdto = new CarDTO();
while(true) {
System.out.println("1. 차량검색 \n2. 차량등록 \n3. 뒤로가기");
int choice = sc.nextInt();
if(choice == 1) {
System.out.println("\t==== 대문자로 입력해주세요 ==== ");
System.out.println("\t예시) k5(x) → K5(o)");
System.out.print("차종 검색 : ");
String cartype = sc.next();
// 위에서 차종을 체크해서 있는지 없는지 확인
// 있으면 있다고 뜨고 차량 검색기능을 불러옴
if(cdao.checkcar(cartype)) {
System.out.println("존재하는 차량입니다.");
System.out.println("차량 정보를 나타냅니다.");
System.out.println(cdao.searchCar(cartype));
break;
// 없으면 아래의 문구가 뜸
} else {
System.out.println("존재하지 않는 차량입니다.");
break;
}
} else if(choice == 2){
// 차량 식별 코드의미
System.out.println("차량번호 등록 : ");
String carnum = sc.next();
condition = false;
for (int i = 0; i < carnum.length(); i++) {
// 아스키 코드로 확인
// 대문자가 들어갔는지 확인 후 들어갔으면 false
char ch = carnum.charAt(i);
if(ch <= 90 && ch >= 65) {
condition = false;
System.out.println("대문자는 사용할 수 없습니다.");
break;
// 소문자가 들어갔으면 false
} else if(ch >= 97 && ch <= 122) {
condition = false;
System.out.println("소문자는 사용할 수 없습니다.");
break;
// 특문 있나 확인후 있으면 false
} else if(ch >= 33 && ch <= 47) {
condition = false;
System.out.println("특수문자는 사용할 수 없습니다.");
break;
} else if(ch == 0) {
condition = false;
System.out.println("NUL이라 안됩니다.");
break;
} else if(ch >= '0' && ch <= '9') {
condition = true;
}
}
// condition = true;
if(condition == true) {
System.out.println("정상적으로 입력되었습니다.");
cdto.setCarnum(carnum);
} else if(!condition) {
System.out.println("숫자형식으로 입력해주세요.");
// JoinView, Modify_MyInfo에서는 하나 틀리면 바로 날라가지만
// 여기서는 다 쓰고 틀리면 날라가게 구현
new Car_Search();
break;
} else {
System.out.println("오류가 발생했습니다.");
new Car_Search();
break;
}
System.out.println("\t==== 대문자로 입력해주세요 ==== ");
System.out.println("\t예시) k5(x) → K5(o)");
System.out.print("차종 등록 : ");
String cartype = sc.next();
System.out.print("주행 거리 등록 : ");
String distance = sc.next();
System.out.print("차량 가격 등록 : ");
String price = sc.next();
System.out.print("차량 연식 등록 : ");
String carage = sc.next();
System.out.print("차량 옵션 등록 : ");
sc = new Scanner(System.in);
String caroption = sc.nextLine();
// System.out.print("아이디 : ");
// String userid = sc.next();
CarDTO car = new CarDTO(carnum, cartype, distance, price, carage, caroption);
// 차량번호가 존재하고 있는지 확인하는 메소드를 불러옴
// 차량번호가 있는지 없는지 확인 후 없으면 등록 가능
if(cdao.checkcar1(carnum)) {
System.out.println("등록 가능한 차량번호입니다.");
// 차량 등록
if(cdao.joincar(car)) {
System.out.println("차량 등록 성공!!");
System.out.println("차량 거래 대기상태로 등록");
cdao.carDeal(car); // 추가
} else {
System.out.println("문제가 발생했습니다!");
}
} else {
// carnum이 동일하면 차량 등록 실패
System.out.println("차량 등록 실패 / 다시 시도해주세요!!");
}
// 뒤로가기
} else if(choice == 3) {
System.out.println("메인으로 돌아갑니다");
new MainView();
}
}
}
}CarDTO 생성
● 차량등록을 위해서 DTO를 생성해주자 package dto;
public class CarDTO {
// 중복되도 되는것만 있으면 구별이 안가니 carnum과 userid로 구별해준다.
// carnum은 차량 식별 번호
private String carnum;
private String cartype;
private String distance;
private String price;
private String carage;
private String caroption;
public CarDTO() {
this.carnum = "";
this.cartype = "";
this.distance = "";
this.price = "";
this.carage = "";
this.caroption ="";
}
public CarDTO(String carnum, String cartype, String distance, String price,
String carage, String caroption) {
this.carnum = carnum;
this.cartype = cartype;
this.distance = distance;
this.price = price;
this.carage = carage;
this.caroption = caroption;
// this.userid = userid;
}
public String getCarnum() {
return carnum;
}
public void setCarnum(String carnum) {
this.carnum = carnum;
}
public String getCartype() {
return cartype;
}
public void setCartype(String cartype) {
this.cartype = cartype;
}
public String getDistance() {
return distance;
}
public void setDistance(String distance) {
this.distance = distance;
}
public String getPrice() {
return price;
}
public void setPrice(String price) {
this.price = price;
}
public String getCarage() {
return carage;
}
public void setCarage(String carage) {
this.carage = carage;
}
public String getCaroption() {
return caroption;
}
public void setCaroption(String caroption) {
this.caroption = caroption;
}
// public String getUserid() {
// return userid;
// }
//
//
// public void setUserid(String userid) {
// this.userid = userid;
// }
@Override
public boolean equals(Object obj) {
if(obj instanceof CarDTO) {
CarDTO cdto = (CarDTO)obj;
return cdto.hashCode() == this.hashCode();
}
return false;
}
@Override
public String toString() {
return "차량번호 : " +carnum + "\n차종 : " + cartype + "\n주행거리 : " + distance
+ "\n가격 : " + price + "\n차량연식 : "
+ carage + "\n차량 옵션 : " + caroption;
}
}Car_search 생성자에서 사용할 CarDAO기능들
// 검색전에 그 차가 있는지 체크하는 메소드
public boolean checkcar(String cartype) {
String sql = "select * from car where cartype=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
rs = ps.executeQuery();
// 중복된게 있어야 true가 되야하므로
// rs.next를 리턴
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkcar 수행 실패! : " + sqle);
}
return false;
} public boolean checkcar1(String carnum) {
String sql = "select * from car where carnum=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
rs = ps.executeQuery();
// 차량 번호가 없어야 넣을 수 있는 기능이니
// 중복된게 없어야 true가 되야하므로
// !rs.next를 리턴
return !rs.next();
} catch (SQLException sqle) {
System.out.println("checkcar(carnum)수행 실패! : " + sqle);
}
return false;
} public boolean joincar(CarDTO car) {
// 헷갈릴 까봐 그냥 전부 적어놈
String sql = "insert into car (carnum,cartype,distance,price,carage,caroption,userid)"
+ "values(?,?,?,?,?,?,?)";
try {
ps= conn.prepareStatement(sql);
ps.setString(1, car.getCarnum());
ps.setString(2, car.getCartype());
ps.setString(3, car.getDistance());
ps.setString(4, car.getPrice());
ps.setString(5, car.getCarage());
ps.setString(6, car.getCaroption());
ps.setString(7, Session.get("login_id"));
// carnum이 동일하지 않는한 등록은 다 가능
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("joincar 수행 실패! : " + sqle);
}
return false;
} public boolean carDeal(CarDTO car) { // 추가
String sql = "insert into dealinfo (carnum,userid,registtime)"
+ "values(?,?,now())";
try {
ps= conn.prepareStatement(sql);
ps.setString(1, car.getCarnum());
ps.setString(2, Session.get("login_id"));
// carnum이 동일하지 않는한 등록은 다 가능
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("joincar 수행 실패! : " + sqle);
}
return false;
}Review
package view;
import java.util.Map;
import java.util.Scanner;
import dao.CarDAO;
import dao.ReviewDAO;
import dao.Session;
import dao.UserDAO;
import dto.ReviewDTO;
public class Review {
public Review( ) {
Scanner sc = new Scanner(System.in);
UserDAO udao = new UserDAO();
ReviewDAO rdao = new ReviewDAO();
CarDAO cdao = new CarDAO();
System.out.println("1. 구매후기 \n2. 쪽지보내기 \n3. 받은쪽지함 \n4. 구매하기 \n5. 판매하기 "
+ "\n6. 찜하기 \n7. 뒤로가기");
int choice = sc.nextInt();
// 뒤로 가기
if(choice == 7) {
System.out.println("메인으로 돌아갑니다");
new MainView();
// 구매후기
} else if(choice == 1) {
System.out.println("제목 입력 : ");
sc = new Scanner(System.in);
String title = sc.nextLine();
System.out.println("내용 입력 : ");
sc = new Scanner(System.in);
String detail = sc.nextLine();
System.out.print("차량번호 입력 : ");
int carnum = sc.nextInt();
ReviewDTO rdto = new ReviewDTO(title, detail, carnum);
if(rdao.writePost(rdto)) {
System.out.println("작성을 완료했습니다.");
} else {
System.out.println("작성을 실패했습니다.");
}
// 쪽지 보내기
} else if(choice == 2) {
System.out.println("보낼 내용을 입력하세요 : ");
sc = new Scanner(System.in);
String msg = sc.nextLine();
System.out.print("보낼 아이디 : ");
String name = sc.next();
if(rdao.sendMsg(msg, name)) {
System.out.println("메세지가 성공적으로 보내졌습니다.");
} else {
System.out.println("메세지 전송 실패!!!");
}
// 받은 쪽지함
} else if(choice == 3) {
System.out.println("1. 쪽지보기 \n2. 쪽지삭제");
int ch = sc.nextInt();
switch (ch) {
case 1:
System.out.println("받은 쪽지 내용을 표시하겠습니다.");
System.out.println( rdao.msgConfirm());
break;
case 2:
System.out.println("쪽지를 삭제하셨습니다.");
rdao.removeMsg();
break;
default:
System.out.println("잘못된 입력하셨습니다!!");
break;
}
// 구매하기
} public boolean saleIdck(String cartype) {
String sql = "select * from car where userid=? and cartype = ?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.setString(2, cartype);
rs = ps.executeQuery();
// 찜할 아이디가 존재하는지 확인하는 메소드
// 그렇기 때문에 데이터베이스에 해당 아이디가 있어야 한다.
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkId 수행 실패! : " + sqle);
}
return false;
}
public boolean buyIdck(String cartype) { // 추가
String sql = "select * from car where userid=? and cartype =?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.setString(2, cartype);
rs = ps.executeQuery();
// 구매 전 동알한 아이디로 구매 불가에 검사하는 거니까
// 중복된게 없어야 true가 되야므로 !rs.next 리턴
return !rs.next();
} catch (SQLException sqle) {
System.out.println("checkDup 수행 실패! : " + sqle);
}
return false;
}
} else if(choice == 5) { // 수정
System.out.println("판매할 차량을 입력하세요 : ");
String cartype = sc.next();
// 판매할 차량과 로그인한 아이디하고 비교해서 있는지 확인
// 있어야 true가 나온다.
if(udao.saleIdck(cartype)) {
// dealinfo에 담긴 데이터가 null이 아니라면 true
if(cdao.tradeStatusck() != null) {
System.out.println(cdao.tradeStatusck());
if(cdao.checkcar(cartype)) {
System.out.println("존재 하는 차량입니다.");
System.out.println("차량 번호를 다시한번 입력해주세요 : ");
String carnum = sc.next();
if(cdao.checkcarnum(carnum)) {
System.out.println("차량 번호를 확인했습니다.");
System.out.println("1. 판매");
System.out.println("2. 취소");
System.out.println("최종 메세지 : ");
int ch = sc.nextInt();
switch (ch) {
case 1:
if(cdao.sellCar(cartype, carnum)) {
System.out.println("차량을 판매 했습니다.");
cdao.delreview(carnum);
cdao.deldealinfo(carnum);
cdao.delcar(cartype, carnum);
System.out.println("==== 판매된 차량은 삭제 ====");
System.out.println("등록한 차종을 삭제 했습니다.");
}
break;
case 2:
System.out.println("취소합니다.");
new Review();
break;
default:
System.out.println("잘못된 번호 입니다.");
break;
}
} else {
System.out.println("존재 하지 않는 차량번호 입니다.");
}
} else {
System.out.println("존재 하지 않는 차량입니다.");
}
} else{
System.out.println("구매 요청 중인 차량이 없습니다.");
}
} else {
System.out.println("등록하지 않은 차량입니다.");
}
} else if(choice == 6) {
System.out.println("찜하기로~");
// 찜하로 가는곳
new Dib();
}
}
}ReviewDTO 생성
● title, detail, carnum을 포장해주기 위해서 먼저 생성해주자! package dto;
public class ReviewDTO {
private String title;
private String detail;
private int carnum;
// private String userid;
public ReviewDTO(String title, String detail, int carnum) {
this.title = title;
this.detail = detail;
this.carnum = carnum;
// this.userid = userid;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDetail() {
return detail;
}
public void setDetail(String detail) {
this.detail = detail;
}
public int getCarnum() {
return carnum;
}
public void setCarnum(int carnum) {
this.carnum = carnum;
}
}ReviewDAO에서 writePost메소드 구현
● ReviewDTO에서 포장했던 것들을 여기서 받는다. public boolean writePost(ReviewDTO rdto) {
String sql = "insert into review(title,detail,carnum,userid,registtime) "
+ "values(?,?,?,?,now())";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, rdto.getTitle());
ps.setString(2, rdto.getDetail());
ps.setInt(3, rdto.getCarnum());
ps.setString(4, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("writePost 수행 실패! : " + sqle);
}
return false;
}ReviewDAO에서 sendMsg메소드 구현
● 메세지를 보내기 위해서 구현 public boolean sendMsg(String msg, String name) {
String sql = "insert into message(send_id,msg,recieve_id,registtime) "
+ "values(?,?,?,now())";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.setString(2, msg);
// name에서 회원가입되지 않은 아이디를 입력하면 오류가 발생한다.
// 그 이유는 message 테이블에서 recieve_id는 user 테이블에서
// userid를 fk해서 받아 왔기 때문에 참조하는 값은 일치해야 한다.
// userid는 Session에 put으로 아이디를 기록해놓기 떼문에
// 아이디를 잘못쓰면 무결성이 깨져서 오류가 발생한다.
// 뜨는 오류 : Cannot add or update a child row: a foreign key constraint fails
// (`project`.`message`, CONSTRAINT `message_fk`
FOREIGN KEY (`recieve_id`) REFERENCES `user` (`userid`))
ps.setString(3, name);
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("sengMsg 수행 실패! : " + sqle);
}
return false;
}ReviewDAO에서 msgConfirm메소드 구현
● 받은 쪽지를 확인하기 위해서 만든 메소드 public String msgConfirm() {
String sql = "select * from message where recieve_id=?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
rs = ps.executeQuery();
if(rs.next()) {
String sid = rs.getString("send_id");
String msg = rs.getString("msg");
String rid = rs.getString("recieve_id");
System.out.println("=========== 쪽지함 ============");
System.out.println("보낸아이디 : " + sid + "\t받는아이디 : "
+ rid + "\n메세지 내용 : " + msg);
System.out.println("==============================");
}
} catch (SQLException sqle) {
System.out.println("MsgConfirm 수행 실패! : " + sqle);
}
return "쪽지가 없습니다.";
}ReviewDAO에서 removeMsg메소드 구현
● 쪽지 삭제 기능을 위한 메소드 public void removeMsg() {
String sql = "delete from message where recieve_id=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("removeMsg 수행 실패! : " + sqle);
}
}CarDAO에서 carinfo메소드 구현
● 차량정보를 보여주기 위해서 구현
public String carinfo() {
String sql = "select * from car";
try {
ps = conn.prepareStatement(sql);
rs = ps.executeQuery();
while(rs.next()) {
String ctype = rs.getString("cartype");
String dis = rs.getString("distance");
String pri = rs.getString("price");
String age = rs.getString("carage");
String option = rs.getString("caroption");
return "차종 : " + ctype + " /주행거리 : " + dis + " /가격 : " + pri +
" /차량연식 : " + age + " /차량옵션 : " + option;
}
} catch (SQLException sqle) {
System.out.println("carinfo 수행 실패! : " + sqle);
}
return null;
}CarDAO에서 buycar메소드 구현
● 차량을 구매하기 위해서 구현 public String buycar(String cartype) {
String sql = "select * from car where cartype=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
rs = ps.executeQuery();
if(rs.next()) {
int cnum = rs.getInt("carnum");
String ctype = rs.getString("cartype");
String dis = rs.getString("distance");
String pri = rs.getString("price");
String age = rs.getString("carage");
String option = rs.getString("caroption");
return "차량번호 : " + cnum + "\t\t차종 : " + ctype + "\t\t주행거리 : " +
dis + "\t\t가격 : " + pri + "\t\t차량연식 : " + age + "\n차량옵션 : " + option;
}
} catch (SQLException sqle) {
System.out.println("buycar 수행 실패! : " + sqle);
}
return null;
}CarDAO에서 checkcar2 메소드 구현
● 마지막으로 구매한 차량에 대해 정보를 보여줌 public String checkcar2(String carnum) {
String sql = "select * from car where carnum=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
rs = ps.executeQuery();
while(rs.next()) {
String cnum = rs.getString("carnum");
String ctype = rs.getString("cartype");
String dis = rs.getString("distance");
String pri = rs.getString("price");
String age = rs.getString("carage");
String option = rs.getString("caroption");
return "차량번호 : " + cnum + "\t\t차종 : " + ctype + "\t\t주행거리 : "
+ dis + "\t\t가격 : " + pri + "\t\t차량연식 : " + age + "\n차량옵션 : " + option;
}
} catch (SQLException sqle) {
System.out.println("checkcar(carnum)수행 실패! : " + sqle);
}
return null;
}CarDAO에 checkcar 메소드 구현
● 차량을 판매하기 위해서 그 차량이 있는지 확인하기 위한 메소드 // 검색전에 그 차가 있는지 체크하는 메소드
public boolean checkcar(String cartype) {
String sql = "select * from car where cartype=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
rs = ps.executeQuery();
// 중복된게 있어야 true가 되야하므로
// rs.next를 리턴
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkcar 수행 실패! : " + sqle);
}
return false;
}CarDAO에 checkcarnum메소드 구현
● 판매하기 위해서 carnum을 다시 체크 public boolean checkcarnum(String carnum) {
String sql = "select * from car where carnum=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
rs = ps.executeQuery();
// 차량 번호가 있어야 판매가 가능하니
// 중복된게 있어야 true가 되야하므로
// rs.next를 리턴
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkcarnum(carnum)수행 실패! : " + sqle);
}
return false;
}CarDAO에 delreview, deldealinfo, delcar메소드 구현
● delreview, deldealinfo는 fk때문에 삭제해줘야 delcar을 할 수 있다. public void delreview(String carnum) {
String sql="delete from review where carnum=? and userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
ps.setString(2, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("delcar수행 실패! : " + sqle);
}
} public void deldealinfo(String carnum) {
String sql="delete from dealinfo where carnum=? and userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
ps.setString(2, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("delcar수행 실패! : " + sqle);
}
} public void delcar(String cartype, String carnum) {
String sql="delete from car where cartype=? and carnum=? and userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
ps.setString(2, carnum);
ps.setString(3, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("delcar수행 실패! : " + sqle);
}
}Dib 클래스 생성
● 찜하기 클래스이다. package view;
import java.util.Scanner;
import dao.CarDAO;
import dao.Session;
import dao.UserDAO;
public class Dib {
public Dib() {
Scanner sc = new Scanner(System.in);
CarDAO cdao = new CarDAO();
UserDAO udao = new UserDAO();
String cartype = "";
int choice = 0;
String userid="";
String carnum = "";
while(true) {
System.out.println("======== 찜하기 =========");
System.out.println("1. 차종으로 찜하기");
// System.out.println("2. 유저아이디로 찜하기");
System.out.println("번호를 고르세요 (종료:0)");
choice = sc.nextInt();
if(choice == 0) {
System.out.println("찜하기를 종료합니다.");
new MainView();
break;
} else if(choice == 1) {
System.out.println("찜하실 차종 입력 : ");
cartype = sc.next();
System.out.println("찜하실 차번호 입력 : ");
carnum = sc.next();
System.out.println("찜하실 아이디 입력 : ");
String name = sc.next();
if(cdao.checkcar(cartype, carnum)) {
System.out.println("존재하는 차량입니다.");
if(udao.dib_Car(cartype, carnum, name)) {
System.out.println("차량을 찜하셨습니다.");
} else {
System.out.println("찜하기 실패!");
}
} else {
System.out.println("존재하지 않는 차량입니다.");
}
// } else if(choice == 2) {
// System.out.print("찜하실 아이디 입력 : ");
// userid=sc.next();
// if(udao.checkId(userid)) {
// System.out.println("아이디가 존재합니다.");
// if(!(userid.equals(Session.get("login_id")))) {
//
// if(udao.dib_Userid(userid)) {
// System.out.println("아이디를 찜하셨습니다.");
// } else {
// System.out.println("아이디 찜하기 실패!!");
// }
// }
// } else {
// System.out.println("아이디가 존재하지 않습니다.");
// }
} else if(!(1 == choice)) {
System.out.println("메뉴를 잘못선택했습니다.(종료:0)");
continue;
}
}
}
}
CarDAO에 있는 checkcar(String cartype)을 사용
● 차종이 있는지 확인 // 검색전에 그 차가 있는지 체크하는 메소드
public boolean checkcar(String cartype) {
String sql = "select * from car where cartype=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
rs = ps.executeQuery();
// 중복된게 있어야 true가 되야하므로
// rs.next를 리턴
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkcar 수행 실패! : " + sqle);
}
return false;
}UserDAO에 dib_Car 메소드 구현
● 차량을 찜하는 메소드
public boolean dib_Car(String cartype) {
String sql = "insert into wish_list (dib_car,userid,dib_time)"
+ "values(?,?,now())";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
ps.setString(2, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("dib_Car 수행 실패! : " + sqle);
}
return false;
}UserDAO에 checkId 메소드 구현
● 아이디가 있는지 확인하는 메소드
public boolean checkId(String userid) {
String sql = "select * from user where userid=?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, userid);
rs = ps.executeQuery();
// 찜할 아이디가 존재하는지 확인하는 메소드
// 그렇기 때문에 데이터베이스에 해당 아이디가 있어야 한다.
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkId 수행 실패! : " + sqle);
}
return false;
}UserDAO에 dib_Userid 메소드 구현
● 아이디를 지정해서 찜할 수 있는 메소드
public boolean dib_Userid (String userid) {
String sql = "insert into wish_list (dib_userid,userid,dib_time)"
+ "values(?,?,now())";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, userid);
ps.setString(2, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("dib_Car 수행 실패! : " + sqle);
}
return false;
}Modify_Myinfo 클래스 생성
● 내정보 수정하는 클래스
package view;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import dao.CarDAO;
import dao.ReviewDAO;
import dao.UserDAO;
import dto.UserDTO;
public class Modify_Myinfo {
public Modify_Myinfo() {
Scanner sc = new Scanner(System.in);
UserDAO udao = new UserDAO();
CarDAO cdao = new CarDAO();
ReviewDAO rdao = new ReviewDAO();
UserDTO udto = new UserDTO();
boolean condition = false;
System.out.println("1. 비밀번호 수정\n2. 핸드폰 번호 수정\n3. 주소 수정\n4. 뒤로가기\n5. 회원탈퇴");
int choice = sc.nextInt();
// 비밀번호 수정
if(choice == 1) {
System.out.print("비밀번호 입력 : ");
String userpw = sc.next();
if(udao.checkpw(userpw)) {
System.out.println("맞는 비밀번호입니다");
System.out.print("새로운 비밀번호 입력 : ");
String userpw2 = sc.next();
if(checkpw2(userpw2)){
// 원래 사용하던 비밀번호를 사용하지 못하게 조건문을 추가
if(!(userpw2.equals(userpw))) {
if(udao.modifypw(userpw2)) {
System.out.println("비밀번호 변경완료");
} else {
System.out.println("비밀번호 변경실패");
}
} else {
System.out.println("기존의 비밀번호를 사용할 수 없습니다.");
}
} else {
System.out.println("불가능한 비밀번호 입니다.");
}
} else {
System.out.println("틀린 비밀번호 입니다.");
}
// 휴대폰 번호 수정
} else if(choice == 2) {
System.out.print("새로운 핸드폰 번호 입력 :");
String userphone = sc.next();
condition = false;
for (int i = 0; i < userphone.length() ; i++) {
// System.out.println(userphone.charAt(i));
// 대문자 확인(아스키 코드)
char ch = userphone.charAt(i);
if(ch <= 90 && ch >= 65) {
// 대문자에 포함되면 false
condition = false;
System.out.println("대문자는 사용할 수 없습니다.");
new MainView();
// 그리고 나가짐
break;
// 대문자를 통과하면 소문자 검사!
} else if(ch >= 97 && ch <= 122) {
// 소문자면 false
condition = false;
System.out.println("소문자는 사용할 수 없습니다.");
new MainView();
break;
// 특문 있나 확인후 있으면 false
} else if(ch >= 33 && ch <= 47) {
condition = false;
System.out.println("특수문자는 사용할 수 없습니다.");
new MainView();
break;
} else if(ch == 0) {
condition = false;
System.out.println("NUL이라 안됩니다.");
new MainView();
break;
} else if(ch >= '0' && ch <= '9') {
condition = true;
}
}
// condition = true;
// 숫자가 11개거나 condition이 true이면 통과
if(userphone.length() ==11 && condition == true) {
if(udao.modifyphone(userphone)) {
System.out.println("핸드폰 번호 변경완료");
// UserDTO에 있는 메소드에 입력
udto.setUserphone(userphone);
} else {
System.out.println("핸드폰 번호 변경실패");
}
// condition이 false면
} else if(!condition) {
System.out.println("숫자만 입력하세요");
// 핸드폰 번호가 11가 아니면
} else if(userphone.length() != 11) {
System.out.println("전화번호는 11자리 입니다.");
} else {
System.out.println("오류가 발생했습니다.");
}
// 주소 수정
} else if(choice == 3) {
System.out.print("새로운 주소 입력 : ");
sc = new Scanner(System.in);
String useraddr = sc.nextLine();
if(udao.modifyaddr(useraddr)) {
System.out.println("주소 변경완료");
} else {
System.out.println("주소 변경실패");
}
// 뒤로 가기
} else if(choice == 4) {
System.out.println("메인으로 돌아갑니다");
new MainView();
// 회원 탈퇴
} else if(choice == 5) {
System.out.print("비밀번호 입력 : ");
String userpw = sc.next();
if(udao.checkpw(userpw)) {
System.out.println("맞는 비밀번호입니다");
// 게시글 삭제
rdao.removeAll();
// 차량 등록한거 전부 삭제
cdao.removeAll();
// 그후에 유저 아이디 삭제
if(udao.userdel()) {
System.out.println("=========== 회원탈퇴 성공 ============");
// 자바에서 프로그램 종료
// 0이면 정상종료
// 1이면 비정상종료
Index.main(null);
}
}
else {
System.out.println("잘못 입력하셨습니다.");
}
}
}
//소문자,대문자, 0~9 숫자, 특수문자 8자리 이상!
public boolean checkpw2(String userpw) {
String passwordPolicy = "^(?=.*[A-Za-z])(?=.*[0-9])(?=.*[$@$!%*#?&])[A-Za-z[0-9]$@$!%*#?&]{8,20}$";
Pattern pattern_pwd = Pattern.compile(passwordPolicy);
Matcher matcher_pwd = pattern_pwd.matcher(userpw);
return matcher_pwd.matches();
}
}UserDAO에 modifyphone 메소드 구현
● 폰번호를 바꾸기 위한 메소드 public boolean modifyphone(String userphone) {
String sql = "update user set userphone = ? where userid = ?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, userphone);
// 애초에 로그인한 사람의 아이디가 필요할 때는 매개변수로 따로 받아오지 않고
// 세션에 세팅되어 있는 것을 사용
ps.setString(2, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("modifyphone 수행 실패! : " + sqle);
}
return false;
}UserDAO에 modifyaddr 메소드 구현
● 주소를 바꾸는 메소드 public boolean modifyaddr(String useraddr) {
String sql = "update user set useraddr = ? where userid = ?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, useraddr);
// 애초에 로그인한 사람의 아이디가 필요할 때는 매개변수로 따로 받아오지 않고
// 세션에 세팅되어 있는 것을 사용
ps.setString(2, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("modifyaddr 수행 실패! : " + sqle);
}
return false;
}UserDAO에 removeAll메소드 구현
● 회원 탈퇴를 위한 메소드
● 회원 탈퇴전에 글쓴것들 삭제 public void removeAll() {
String sql = "delete from review where userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("removeAll 수행 실패! : " + sqle);
}
}UserDAO에 removeAll메소드 구현
● 회원 탈퇴를 위한 메소드
● 회원 탈퇴전에 차량 정보 삭제 public void removeAll() {
String sql = "delete from car where userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("removeAll 수행 실패! : " + sqle);
}
}Session
● dao에 생성해 준다.
● 아이디에 대한 정보가 담겨있다.
● 로그인할때 put으로 보내주고 Hashmap으로 여기에 저장한다. package dao;
import java.util.HashMap;
// 아이디 데이터 가지고 있는 공간
public class Session {
//Session.datas.put("login_id","apple");
private static HashMap<String, String> datas = new HashMap<String, String>();
//Session.put("login_id","apple");
public static void put(String key, String value) {
datas.put(key, value);
}
public static String get(String key) {
return datas.get(key);
}
} UserDAO
package dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import dto.UserDTO;
public class UserDAO {
// 밖에서 사용하지 않고 내부에서 사용할꺼니까 private 써야한다.
private Connection conn;
private PreparedStatement ps;
private ResultSet rs;
// 다리 만들기
public UserDAO() {
conn = DBConnection.getConnection();
}
// JoinView클래스에 있는 중복검사 메소드 기능 구현
public boolean checkDup(String userid) {
String sql = "select * from user where userid=?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, userid);
rs = ps.executeQuery();
// 회원가입 전에 검사하는 거니까
// 중복된게 없어야 true가 되야므로 !rs.next 리턴
return !rs.next();
} catch (SQLException sqle) {
System.out.println("checkDup 수행 실패! : " + sqle);
}
return false;
}
// 비밀번호를 재입력받는 거기 때문에 기존에 비밀번호가 있어야 한다.
public boolean checkpw(String userpw) {
String sql = "select * from user where userpw=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, userpw);
// 만들어놓은 쿼리문을 수행
rs = ps.executeQuery();
// 그럼 select문 같은 경우엔 검색된 결과가 있어서 어떤 테이블 형태의 검색결과물이 나오던가
// 혹은 검색된 결과가 없으니 컬럼명만 나온다.
// 이거는 워크벤치에서 수행했을 때 결과창을 보면 알 수 있다.
// 그 때 검색된 결과물이 있다면 rs.next()로 첫번째 행부터 하나씩 이동시킬 수 있고
// rs.next()를 쓰면 첫번째 행을 가리키고 그곳에 검색된 결과가 있으면 true, 아니면 false
// 검색결과가 있는지 확인하려면 그냥 rs.next()를 리턴해야 한다.
// 그래서 아이디 중복체크같은 경우는 검색결과가 없어서 true니까 !rs.next()인데
// 지금 같은 경우에는 존재하는지 확인해야 하므로 그대로 rs.next()로 리턴하는게 맞다.
// 비밀번호를 체크하는거니까 기존에 있어야 true
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkpw 수행 실패! : " + sqle);
}
return false;
}
// JoinView클래스에 있는 회원가입 메소드 기능 구현
public boolean join(UserDTO user) {
// values(?,?,?,?,?,?)에서 ?는 (userid,userpw,username,userphone,useraddr)
// 값들이다.
String sql = "insert into user (userid,userpw,username,userphone,useraddr) "
+ "values(?,?,?,?,?)";
System.out.println(user.toString());
try {
ps = conn.prepareStatement(sql);
ps.setString(1, user.getUserid());
ps.setString(2, user.getUserpw());
ps.setString(3, user.getUsername());
ps.setString(4, user.getUserphone());
ps.setString(5, user.getUseraddr());
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("join sql 실패! : " + sqle);
}
return false;
}
// LoginView에서 매개변수를 받아와서 로그인 기능 구현
public boolean login(String userid, String userpw) {
String sql = "select * from user where userid =? and userpw=?";
try {
ps =conn.prepareStatement(sql);
ps.setString(1, userid);
ps.setString(2, userpw);
rs = ps.executeQuery();
if(rs.next()) {
// Session 클래스에 hashmap으로 아이디 데이터 기록해서
// put으로 저장하고 get으로 가져올 수 있게 구성
Session.put("login_id", userid);
return true;
}
} catch (SQLException sqle) {
System.out.println("login 수행 실패! : " + sqle);
}
return false;
}
public String myInfo() {
String sql = "select * from user where userid =?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
rs = ps.executeQuery();
// userid가 같은 행을 찾으면 하나만 나온다.
// rs.next()는 검색결과에서 행을 아래로 하나 이동하며 그 이동한 곳에
// 행이 있으면 true입니다.
if(rs.next()) {
String id = rs.getString("userid");
String name = rs.getString("username");
String phonenum = rs.getString("userphone");
String addr = rs.getString("useraddr");
return "아이디 : " + id + "\n이름 : " + name +
"\n핸드폰 번호 : " + phonenum + "\n주소 : " + addr;
}
} catch (SQLException sqle) {
System.out.println("MyInfo 수행 실패! : " + sqle);
}
return null;
}
public boolean modifypw(String userpw2) {
String sql = "update user set userpw = ? where userid = ?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, userpw2);
ps.setString(2, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("modifypw 수행 실패! : " + sqle);
}
return false;
}
public boolean modifyphone(String userphone) {
String sql = "update user set userphone = ? where userid = ?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, userphone);
// 애초에 로그인한 사람의 아이디가 필요할 때는 매개변수로 따로 받아오지 않고
// 세션에 세팅되어 있는 것을 사용
ps.setString(2, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("modifyphone 수행 실패! : " + sqle);
}
return false;
}
public boolean modifyaddr(String useraddr) {
String sql = "update user set useraddr = ? where userid = ?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, useraddr);
// 애초에 로그인한 사람의 아이디가 필요할 때는 매개변수로 따로 받아오지 않고
// 세션에 세팅되어 있는 것을 사용
ps.setString(2, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("modifyaddr 수행 실패! : " + sqle);
}
return false;
}
public boolean userdel() {
String sql = "delete from user where userid=?";
try {
ps = conn.prepareStatement(sql);
// 애초에 로그인한 사람의 아이디가 필요할 때는 매개변수로 따로 받아오지 않고
// 세션에 세팅되어 있는 것을 사용
ps.setString(1, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("userdel 수행 실패! : " + sqle);
}
return false;
}
// 차종, 차번호를 받아서 wish_list에 추가한다.
public boolean dib_Car(String cartype, String carnum, String name) {
String sql = "insert into wish_list (dib_car,dib_carnum,dib_userid,userid,dib_time)"
+ "values(?,?,?,?,now())";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
ps.setString(2, carnum);
ps.setString(3, name);
ps.setString(4, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("dib_Car 수행 실패! : " + sqle);
}
return false;
}
// public boolean dib_Userid (String userid) {
// String sql = "insert into wish_list (dib_userid,userid,dib_time)"
// + "values(?,?,now())";
//
// try {
// ps = conn.prepareStatement(sql);
// ps.setString(1, userid);
// ps.setString(2, Session.get("login_id"));
//
// return ps.executeUpdate() == 1;
//
// } catch (SQLException sqle) {
// System.out.println("dib_Car 수행 실패! : " + sqle);
// }
// return false;
// }
//
// public boolean checkId(String userid) {
// String sql = "select * from user where userid=?";
// try {
// // 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// // prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
// ps = conn.prepareStatement(sql);
// ps.setString(1, userid);
//
// rs = ps.executeQuery();
//
// // 찜할 아이디가 존재하는지 확인하는 메소드
// // 그렇기 때문에 데이터베이스에 해당 아이디가 있어야 한다.
// return rs.next();
// } catch (SQLException sqle) {
// System.out.println("checkId 수행 실패! : " + sqle);
// }
// return false;
// }
public String viewDib() {
String sql = "select * from wish_list where userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
rs = ps.executeQuery();
while(rs.next()) {
String car = rs.getString("dib_car");
String num = rs.getString("dib_carnum");
String name = rs.getString("dib_userid");
System.out.println("\n\t찜한 차종 : " + car + "\n\t찜한 차번호 : " + num + "\n\t찜한 아이디 : " + name);
}
// } catch(NullPointerException sqle) {
// System.out.println("null에러 잡자");
}
catch (SQLException sqle) {
System.out.println("viewDib 수행 실패! : " + sqle);
}
return "찜한 목록이 없네요";
}
public boolean saleIdck(String cartype) {
String sql = "select * from car where userid=? and cartype = ?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.setString(2, cartype);
rs = ps.executeQuery();
// 찜할 아이디가 존재하는지 확인하는 메소드
// 그렇기 때문에 데이터베이스에 해당 아이디가 있어야 한다.
return rs.next();
} catch (SQLException sqle) {
System.out.println("saleIdck수행 실패! : " + sqle);
}
return false;
}
public boolean buyIdck(String cartype) { // 추가
String sql = "select * from car where userid=? and cartype =?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.setString(2, cartype);
rs = ps.executeQuery();
// 구매 전 동알한 아이디로 구매 불가에 검사하는 거니까
// 중복된게 없어야 true가 되야므로 !rs.next 리턴
return !rs.next();
} catch (SQLException sqle) {
System.out.println("butIdck 수행 실패! : " + sqle);
}
return false;
}
} CarDAO
package dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import com.mysql.cj.jdbc.result.ResultSetMetaData;
import dto.CarDTO;
public class CarDAO {
private Connection conn;
private PreparedStatement ps;
private ResultSet rs;
public CarDAO() {
conn = DBConnection.getConnection();
}
// 체크 후 차종이 있으면 검색하는 메소드
public String searchCar(String cartype) {
String sql = "select * from car where cartype=?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
rs = ps.executeQuery();
// rs.next() : 검색된 결과에서 행을 하나 이동시키며 이동된 곳에 존재한다면 true, 아니라면 false
while(rs.next()) {
// 컬럼명을 작성해주면 가리키고 있는 행의 해당 컬럼값을 가지고 온다.
String ctype = rs.getString("cartype");
String dis = rs.getString("distance");
String pri = rs.getString("price");
String age = rs.getString("carage");
String option = rs.getString("caroption");
// return "차종 : " + ctype + "\n주행거리 : " + dis + "\n가격 : " + pri +
// "\n차량연식 : " + age + "\n차량옵션 : " + option;
System.out.println("차종 : " + ctype + "\n주행거리 : " + dis + "\n가격 : " + pri +
"\n차량연식 : " + age + "\n차량옵션 : " + option);
}
} catch (SQLException sqle) {
System.out.println("searchCar 수행 실패! : " + sqle);
}
return "더이상 차량 정보가 없습니다.";
}
public String carinfo() {
String sql = "select * from car";
try {
ps = conn.prepareStatement(sql);
rs = ps.executeQuery();
while(rs.next()) {
String ctype = rs.getString("cartype");
String dis = rs.getString("distance");
String pri = rs.getString("price");
String age = rs.getString("carage");
String option = rs.getString("caroption");
// return "차종 : " + ctype + " /주행거리 : " + dis + " /가격 : " + pri +
// " /차량연식 : " + age + " /차량옵션 : " + option;
System.out.println("차종 : " + ctype + "\n주행거리 : " + dis + "\n가격 : " + pri +
"\n차량연식 : " + age + "\n차량옵션 : " + option);
}
} catch (SQLException sqle) {
System.out.println("carinfo 수행 실패! : " + sqle);
}
return "더이상 차량정보가 없습니다.";
}
// 검색전에 그 차가 있는지 체크하는 메소드
public boolean checkcar(String cartype) {
String sql = "select * from car where cartype=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
rs = ps.executeQuery();
// 중복된게 있어야 true가 되야하므로
// rs.next를 리턴
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkcar 수행 실패! : " + sqle);
}
return false;
}
public boolean joincar(CarDTO car) {
// 헷갈릴 까봐 그냥 전부 적어놈
String sql = "insert into car (carnum,cartype,distance,price,carage,caroption,userid)"
+ "values(?,?,?,?,?,?,?)";
try {
ps= conn.prepareStatement(sql);
ps.setString(1, car.getCarnum());
ps.setString(2, car.getCartype());
ps.setString(3, car.getDistance());
ps.setString(4, car.getPrice());
ps.setString(5, car.getCarage());
ps.setString(6, car.getCaroption());
ps.setString(7, Session.get("login_id"));
// carnum이 동일하지 않는한 등록은 다 가능
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("joincar 수행 실패! : " + sqle);
}
return false;
}
public boolean checkcar1(String carnum) {
String sql = "select * from car where carnum=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
rs = ps.executeQuery();
// 차량 번호가 없어야 넣을 수 있는 기능이니
// 중복된게 없어야 true가 되야하므로
// !rs.next를 리턴
return !rs.next();
} catch (SQLException sqle) {
System.out.println("checkcar(carnum)수행 실패! : " + sqle);
}
return false;
}
public boolean checkcarnum(String carnum) {
String sql = "select * from car where carnum=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
rs = ps.executeQuery();
// 차량 번호가 있어야 판매가 가능하니
// 중복된게 있어야 true가 되야하므로
// rs.next를 리턴
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkcarnum(carnum)수행 실패! : " + sqle);
}
return false;
}
public void removeAll() {
String sql = "delete from car where userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("removeAll 수행 실패! : " + sqle);
}
}
public String buycar(String cartype) {
String sql = "select * from car where cartype=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
rs = ps.executeQuery();
if(rs.next()) {
int cnum = rs.getInt("carnum");
String ctype = rs.getString("cartype");
String dis = rs.getString("distance");
String pri = rs.getString("price");
String age = rs.getString("carage");
String option = rs.getString("caroption");
return "차량번호 : " + cnum + "\t\t차종 : " + ctype + "\t\t주행거리 : " + dis + "\t\t가격 : " + pri + "\t\t차량연식 : " + age + "\n차량옵션 : " + option;
}
} catch (SQLException sqle) {
System.out.println("buycar 수행 실패! : " + sqle);
}
return null;
}
public String checkcar2(String carnum) {
String sql = "select * from car where carnum=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
rs = ps.executeQuery();
while(rs.next()) {
String cnum = rs.getString("carnum");
String ctype = rs.getString("cartype");
String dis = rs.getString("distance");
String pri = rs.getString("price");
String age = rs.getString("carage");
String option = rs.getString("caroption");
System.out.println("차량번호 : " + cnum + "\t\t차종 : " + ctype + "\t\t주행거리 : " + dis + "\t\t가격 : " + pri + "\t\t차량연식 : " + age + "\n차량옵션 : " + option;);
}
} catch (SQLException sqle) {
System.out.println("checkcar2 수행 실패! : " + sqle);
}
return null;
}
public boolean sellCar(String cartype,String carnum) {
String sql ="select * from car where cartype=? and carnum=? and userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
ps.setString(2, carnum);
ps.setString(3, Session.get("login_id"));
rs = ps.executeQuery();
return rs.next();
} catch (SQLException sqle) {
System.out.println("sellCar수행 실패! : " + sqle);
}
return false;
}
public void deldealinfo(String carnum) {
String sql="delete from dealinfo where carnum=? and userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
ps.setString(2, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("deldealinfo수행 실패! : " + sqle);
}
}
public void delreview(String carnum) {
String sql="delete from review where carnum=? and userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, carnum);
ps.setString(2, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("delreview수행 실패! : " + sqle);
}
}
public void delcar(String cartype, String carnum) {
String sql="delete from car where cartype=? and carnum=? and userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
ps.setString(2, carnum);
ps.setString(3, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("delcar수행 실패! : " + sqle);
}
}
public boolean carDeal(CarDTO car) { // 추가
String sql = "insert into dealinfo (carnum,userid,registtime)"
+ "values(?,?,now())";
try {
ps= conn.prepareStatement(sql);
ps.setString(1, car.getCarnum());
ps.setString(2, Session.get("login_id"));
// carnum이 동일하지 않는한 등록은 다 가능
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("carDeal 수행 실패! : " + sqle);
}
return false;
}
public boolean registDeal(String carnum) { //추가
// 구매할 때 dealinfo 테이블에 "구매 요청"이라는 문구를 업데이트
String sql = "update dealinfo set tradestatus = \"구매 요청\" where carnum = ?";
try {
ps= conn.prepareStatement(sql);
ps.setString(1, carnum);
// ps.setString(2, Session.get("login_id"));
// carnum이 동일하지 않는한 등록은 다 가능
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("registDeal 수행 실패! : " + sqle);
}
return false;
}
public String tradeStatusck() { // 추가
String sql ="select * from dealinfo where userid = ?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
rs = ps.executeQuery();
if(rs.next()) {
int tnum = rs.getInt("tradenum");
String tstatus = rs.getString("tradestatus");
String rgtime = rs.getString("registtime");
String cnum = rs.getString("carnum");
String uid = rs.getString("userid");
// tradestatus에서 "구매 요청"이라면 여기서 비교해서 같으니까 true
if(tstatus.equals("구매 요청")) {
return "거래번호 : " + tnum + "\t\t거래상태 : "
+ tstatus + "\t\t등록시간 : " + rgtime + "\t\t차량번호 : "
+ cnum + "\t\t아이디 : " + uid;
} else {
return null;
}
}
} catch (SQLException sqle) {
System.out.println("tradStatusck수행 실패! : " + sqle);
}
return null;
}
// 차종하고 차번호를 입력받아서 찜하기전에 존재하는지 확인
public boolean checkcar(String cartype, String carnum) {
String sql = "select * from car where cartype=? and carnum=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, cartype);
ps.setString(2, carnum);
rs = ps.executeQuery();
// 중복된게 있어야 true가 되야하므로
// rs.next를 리턴
return rs.next();
} catch (SQLException sqle) {
System.out.println("checkcar 수행 실패! : " + sqle);
}
return false;
}
}
ReviewDAO
package dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import dto.ReviewDTO;
public class ReviewDAO {
private Connection conn;
private PreparedStatement ps;
private ResultSet rs;
public ReviewDAO() {
conn = DBConnection.getConnection();
}
public boolean writePost(ReviewDTO rdto) {
String sql = "insert into review(title,detail,carnum,userid,registtime) "
+ "values(?,?,?,?,now())";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, rdto.getTitle());
ps.setString(2, rdto.getDetail());
ps.setInt(3, rdto.getCarnum());
ps.setString(4, Session.get("login_id"));
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("writePost 수행 실패! : " + sqle);
}
return false;
}
public boolean sendMsg(String msg, String name) {
String sql = "insert into message(send_id,msg,recieve_id,registtime) "
+ "values(?,?,?,now())";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.setString(2, msg);
// name에서 회원가입되지 않은 아이디를 입력하면 오류가 발생한다.
// 그 이유는 message 테이블에서 recieve_id는 user 테이블에서
// userid를 fk해서 받아 왔기 때문에 참조하는 값은 일치해야 한다.
// userid는 Session에 put으로 아이디를 기록해놓기 떼문에
// 아이디를 잘못쓰면 무결성이 깨져서 오류가 발생한다.
// 뜨는 오류 : Cannot add or update a child row: a foreign key constraint fails
// (`project`.`message`, CONSTRAINT `message_fk` FOREIGN KEY (`recieve_id`) REFERENCES `user` (`userid`))
ps.setString(3, name);
return ps.executeUpdate() == 1;
} catch (SQLException sqle) {
System.out.println("sengMsg 수행 실패! : " + sqle);
}
return false;
}
public String msgConfirm() {
String sql = "select * from message where recieve_id=?";
try {
// 만들어논 다리를 이용(만들어 놓은 다리 위를 왔다갔다 할 택배차 만들기)
// prepareStatement 메소드에 우리가 시행하고자 할 sql문을 넘겨주면서 뽑아준다.
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
rs = ps.executeQuery();
while(rs.next()) {
String sid = rs.getString("send_id");
String msg = rs.getString("msg");
String rid = rs.getString("recieve_id");
System.out.println("=========== 쪽지함 ============");
System.out.println("보낸아이디 : " + sid + "\t받는아이디 : "
+ rid + "\n메세지 내용 : " + msg);
System.out.println("==============================");
}
} catch (SQLException sqle) {
System.out.println("MsgConfirm 수행 실패! : " + sqle);
}
return "쪽지가 없습니다.";
}
public void removeMsg() {
String sql = "delete from message where recieve_id=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("removeMsg 수행 실패! : " + sqle);
}
}
public void removeAll() {
String sql = "delete from review where userid=?";
try {
ps = conn.prepareStatement(sql);
ps.setString(1, Session.get("login_id"));
ps.executeUpdate();
} catch (SQLException sqle) {
System.out.println("removeAll 수행 실패! : " + sqle);
}
}
}
최선을 다하자!!
0개의 댓글
관련 채용 정보
