코딩하는 솔라솔

디자인패턴 정리 - 어댑터 패턴, 퍼사드 패턴

솔라솔 — Fri, 1 Dec 2023 13:06:18 +0900

안녕하세요. 솔라솔입니다.

오늘은 어댑터 패턴과 퍼사드 패턴에 대한 공부한것을 정리하고자 합니다.

☀️ 어댑터 패턴 (변환)

✅ 목적: 클래스의 인터페이스를 클라이언트가 원하는 형태의 또다른 인터페이스로 변환.

어댑터는 호환되지 않는 인터페이스 때문에 동작하지 않는 클래스들을 함께 동작할 수 있도록 만들어줌

어댑터는 우리 주변에서도 쉽게 볼 수 있습니다. 흔히 말하는 변압기죠. 한국에서 사용하던 충전기를 해외에서 사용하려면 플러그 모양을 바꿀 어댑터가 필요합니다. 이와 같이 어댑터는 내가 가지고 있는 인터페이스를 다른 곳에 적용할 인터페이스로 바꾸어 주는 역할을 합니다.

✅ 객체를 감싸는 역할을 합니다. 따라서 Wrapper Pattern 이라고도 불립니다. 서로 다른 인터페이스를 동일하게 변환 시키는 거죠.

어댑터

✅ 문제: 사용 객체의 API 가 서로 다름

✅ 해결 방법: 함수를 변환하는 객체를 중간에 넣음

✅ 결과: 변경 최소화

✅ 객체지향어댑터

기존 소프트웨어 시스템에서 새로운 업체에서 제공한 클래스 라이브러리를 사용해야한다고 가정.

새로 채택한 업체에서 사용하는 인터페이스가 기존업체에서 사용하던 인터페이스와 다르다면?

기존 코드를 바꿀 수 없다면, 새로 사용하기로 한 업체에서 사용하는 인터페이스를 기존에 사용하던 인터페이스에 적응시켜주는 클래스를 만들어서 사용

어댑터는 클라이언트로부터 요청을 받아서 새로운 업체에서 제공하는 클래스에서 받아들일 수 있는 형태의 요청으로 변환시켜주는 중개인 역할을 함

public interface Duck {
	public void quack();
    public void fly();
}

public class MallardDuck implements Duck {
	public void quack()  {
    	System.out.println("Quack");
    }
    public void fly ()   {
    	System.out.println("I'm flying");
    }
}

public interface Turkey  {
	public void gobble ();
    public void fly ();
}

public class WildTurkey implements Turkey {
	public void gobble() {
    	System.out.println("Gobble gobble");
    }
    public void fly() {
        System.out.println("I'm flying a short distance");
    }
}

➡️ Duck 객체가 모자라서 Turkey 객체를 대신 사용해야하는 상황이라고 가정

인터페이스가 다르기에 바로 Turkey 객체를 사용할 수는 없다. 이때 필요한것이 바로 어댑터이다.

어댑터 구현

// 우선 적응시킬 형식의 인터페이스를 구현해야 한다. 즉 클라이언트에서 원하는 인터페이스를 구현해야 한다.
public class TurkeyAdapter implements Duck { 
   

    private final Turkey turkey;

    public TurkeyAdapter(Turkey turkey) { // 그리고 기존 형식 객체의 레퍼런스가 필요한다.
        this.turkey = turkey;
    }

    @Override
    public void quack() {
        turkey.gobble();
    }

    /*
     두 인터페이스에 모두 fly가 있지만 turkey의 fly() 메소드를 Duck의 fly() 메소드에 대응시키도록 작성 
     */
    @Override
    public void fly() {
        for (int i = 0; i < 5; i++) {
            turkey.fly();
        }
    }
}

public class DuckTestDrive {

    public static void main(String[] args) {
        Duck duck = new MallardDuck();
        Turkey turkey  = new WildTurkey();
        Duck turkeyAdapter = new TurkeyAdapter(turkey);

        System.out.println(" turkey said that");
        turkey.gobble();
        turkey.fly();

        System.out.println("\n duck said that");
        testDuck(duck);

        System.out.println("\n turkeyAdapter said that");
        testDuck(turkeyAdapter);
    }

    private static void testDuck(Duck duck) {
        duck.quack();
        duck.fly();
    }

}

=======================================================
turkey said that
gobble
short fly

duck said that
quack
fly

turkeyAdapter said that
gobble
short fly
short fly
short fly
short fly
short fly

클라이언트의 testDuck() 메소드는 오리와 칠면조를 전혀 구분하지 못한다.

이제 어댑터가 어떤 식으로 작동하는지 살펴보자

클라이언트는 타깃 인터페이스에 맞게 구현되어 있으며, 타깃 인터페이스로 메소드를 호출해서 어댑터에 요청을 보낸다.
어댑터는 타깃 인터페이스를 구현하며, 어댑티 인스턴스를 가지고 있다. 어댑터는 어댑티 인터페이스로 그 요청을 어댑티에 관한(하나 이상의) 메소드 호출로 변환한다.
클라이언트는 호출 결과를 받긴 하지만 중간에 어댑터가 있다는 사실을 모르므로, 클라이언트와 어댑티는 서로 분리되어 있다.

Q. 어댑터가 얼마나 적응시켜 줘야 할까? 대형 타깃 인터페이스를 구현해야 한다면 할 일이 정말 많아지지 않을까?

어댑터 구현은 타깃 인터페이스로 지원해야 하는 인터페이스의 크기에 비례해서 복잡해진다. 하지만 다른 대안이 없다. 클라이언트에서 호출하는 부분을 새로운 인터페이스에 맞춰서 고치려면 정말 많은 부분을 고려해야 하고, 코드도 많이 고쳐야 한다. 이런 방법보다는 모든 변경 사항을 캡슐화할 어댑터 클래스 하나만 제공하는 방법이 더 나을 것이다.

Q. 하나의 어댑터는 하나의 클래스만 감싸야 할까?

어댑터 패턴은 하나의 인터페이스를 다른 인터페이스로 변환하는 용도로 쓰인다. 하나의 어댑터에서 타깃 인터페이스를 구현하려고 2개 이상의 어댑티를 감싸야 하는 상황도 생길 수 있다. 사실 이런 내용은 퍼사드 패턴과 관련이 있으므로 퍼사드 패턴 때 다시 보자.

Q. 시스템에 오래된 부분과 새로 만든 부분이 섞여 있으면 어떻게 해야할까?? 어떤 곳에는 어댑터를 사용하고 다른 곳에서 어댑터로 감싸지 않은 인터페이스를 사용하면 헷갈리지 않을까?

이런 상황에서는 두 인터페이스를 모두 지원하는 다중 어댑터(Two Way Adapter)를 만들면 된다. 다중 어댑터로 필요한 인터페이스를 둘 다 구현해서 어댑터가 기존 인터페이스와 새로운 인터페이스 역할을 할 수 있게 하면 된다.

https://velog.io/@ljo_0920/%EB%94%94%EC%9E%90%EC%9D%B8-%ED%8C%A8%ED%84%B4-%EC%96%B4%EB%8C%91%ED%84%B0-%ED%8D%BC%EC%82%AC%EB%93%9C

디자인 패턴 - 어댑터, 퍼사드

헤드 퍼스트 디자인 패턴을 읽고 정리한 글입니다.어댑터 패턴 : 특정 클래스 인터페이스를 클라이언트에서 요구하는 다른 인터페이스로 변환한다. 인터페이스가 호환되지 않아 같이 쓸 수 없

velog.io

사례2. Enumeration 을 Iterator 에 적응시키기

Enumeration

Enumeration을 리턴하는 elements() 메소드가 구현되어있었던, 초기 컬렉션 형식 (Vector, Stack, Hashtable 등)은 Enumeration인터페이스를 사용하면 컬렉션내에서 각 항목이 관리되는 방식에는 신경 쓸 필요 없이 컬렉션의 모든 항목에 접근이 가능하다.

Iterator

최근에는 Enumeration과 마찬가지로 컬렉션에 있는 일련의 항목들에 접근할 수 있게 해주면서 항목을 제거할 수도 있게 해주는 Iterator 라는 인터페이스를 사용하기 시작했다..

Enumeration vs Iterator

Enumeration 인터페이스를 사용하는 구형코드를 다뤄야할 때도 가끔 있지만, 새로운 코드를 만들 때는 Iterator 만 사용하는 것이 좋다.

이때 어댑터 패턴을 적용해보자.

Iterator - 타겟 인터페이스

Enumeration - 어댑티 인터페이스

그런데 Iterator의 remove() 메소드는 Enumeration에는 이런 기능을 제공하는 메소드가 없다.

그렇다면, remove() 메소드는 어떻게?

먼저 타깃 인터페이스를 구현하고, 어댑티 객체로 구성된 어댑터를 구현해야한다.

hasNext() 와 next() 메소드는 타깃에서 어댑티로 바로 연결된다.

remove() 는 어떻게 처리할까?

✅ 어댑터 차원에서 완벽하게 작동하는 remove() 메소드의 구현방법은 없다. 따라서 그나마 좋은 방법은 런타임 예외를 던지는 것

✅ Iterator 인터페이스는 remove() 는 default method로 UnsupportedOperationExcpetion을 던지고 있다.

이처럼 메소드가 일대일로 대응되지 않는 상황에서는 어댑터를 완벽하게 적용할 수 없다. 클라이언트는 예외 발생 가능성을 염두에 두고 있어야 하기 때문이다. 하지만 클라이언트에서 주의를 기울이고, 어댑터 문서를 잘 만들어 두면 괜찮을 것이다.

public class EnumerationIterator implements Iterator {
    
    Enumeration enumeration;

    public EnumerationIterator(Enumeration enmt) {
        this.enumeration = enmt;
    }

    @Override
    public boolean hasNext() {
        return enumeration.hasMoreElements();
    }

    @Override
    public Object next() {
        return enumeration.nextElement();
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

public class Iterator2 {
	public static void printIterator(Iterator it) {
    	while (it.hasNext()) {
        	System.out.println(" " + it.next());
        }
    }
    
    public static void main(String[] args) {
    	Vector v = new Vector();
        for (int i = 0; i < 10; i ++) {
        	v.add(i);
        }
        Enumeration e = v.elements();
        EnumerationIterator it = new EnumerationIterator(e);
        Iterator2.printIterator(it);
    }
}

☀️ 퍼사드 패턴 (통합)

목적: 서브시스템에 있는 여러개의 인터페이스를 통합하는 한 개의 인터페이스를 제공

퍼사드는 서브 시스템을 쉽게 사용할 수 있도록 해주는 고급 수준의 인터페이스를 정의

지금까지 어댑터패턴을 써서 어떤 클래스의 인터페이슬르 클라이언트가 원하는 인터페이스로 변환하는 방법을 이용하여 구현했다.

이제 조금 다른 이유로 인터페이스를 변경하는 방법인 퍼사드패턴을 알아보자.

퍼사드패턴은 인터페이스를 단순하게 바꾸고자 인터페이스를 변경한다.

데코레이터 vs 어댑터 vs 퍼사드

세개의 패턴 모두 객체를 감싸고 있는 공통점이 있다. 하지만 사용하는 용도가 각각 다르다.

➡️ 데코레이터는 인터페이스는 바꾸지 않고 감싸고 있는 객체의 행동과 책임을 확장하는 용도로 사용

➡️ 어댑터는 하나의 인터페이스를 다른 인터페이스로 변환하는 용도로 사용

➡️ 퍼사드는 인터페이스를 간단하게 변경하는 용도로 사용

홈시어터를 구축하는것을 가정해보자.

popper.on();
popper.pop();

lights.dim(10);
screen.down();
projector.on();
projector.setInput(dvd);
projector.wideScreenMode();

amp.on();
amp.setDvd(dvd);
amp.setSurroundSound();
amp.setVolume(5);

dvd.on();
dvd.play(movie);

위와 같은 클래스와 메소드가 필요할 것이다.

클래스가 6개나 필요하고, 만약 영화가 끝나면 어떻게 해야할까?, 방금 했던 일을 전부 역순으로 처리해야 하지 않을까? 다른 라디오나 시스템이 업그레이드하면 이런 복잡한 작동 방법을 또 배워야 하지 않을까?

➡️ 이렇게 복잡한 일을 퍼사드 패턴으로 간단하게 처리할 수 있다.

✅ 홈시어터 시스템용 퍼사드를 만들어보자.

watchMovie()와 같이 몇 가지 간단한 메소드만 들어있는 HomeTheaterFacade 클래스를 새로 만들어야 한다.

✅ 퍼사드 클래스는 홈시어터 구성 요소를 하나의 서브시스템으로 간주한다.

➡️ watchMovie() 메서드는 서브시스템의 메소드를 호출해서 필요한 작업을 처리한다.

✅ 이제 클라이언트 코드는 서비스시템이 아닌 홈시어터 퍼사드에 있는 메서드를 호출한다.

➡️ watchMovie() 메서드만 호출하면 조명, 스트리밍 플레이어, 앰프 등 알아서 준비된다.

✅ 퍼사드를 쓰더라도 서브시스템에 여전히 직접 접근할 수 있다.

➡️ 서브시스템 클래스의 고급 기능이 필요하면 언제든지 사용 가능하다.

public class HomeTheaterFacade {

    // composition 부분, 사용하고자 하는 서브시스템의 모든 구성 요소가 인스턴스 변수 형태로 저장된다.
    private Amplifier amp;
    private Tuner tuner;
    private DvdPlayer dvd;
    private CdPlayer cd;
    private Projector projector;
    private TheaterLights lights;
    private Screen screen;
    private PopcornPopper popper;

    public HomeTheaterFacade(Amplifier a, Tuner t, DvdPlayer d, CdPlayer c,
        Projector p,
        TheaterLights l, Screen s, PopcornPopper pp) {
        this.amp = a;
        this.tuner = t;
        this.dvd = d;
        this.cd = c;
        this.projector = p;
        this.lights = l;
        this.screen = s;
        this.popper = pp;
    }

    public void watchMovie(String movie) {
        System.out.println("영화 볼 준비 중");
        popper.on();
        popper.pop();

        lights.dim(10);
        screen.down();
        projector.on();
        projector.wideScreenMode();

        amp.on();
        amp.setDvd(player);
        amp.setSurroundSound();
        amp.setVolume(5);

        dvd.on();
        dvd.play(movie);
    }
    
    public void endMovie() {
        System.out.println("홈시어터 끄는 중");
        popper.off();
        lights.on();
        screen.up();
        projector.off();
        amp.off();
        dvd.stop();
        dvd.eject();
        dvd.off();
    }
}

각 서브시스템에 들어있는 구성요소에게 위임하여 단순화된 인터페이스를 제공한다.

public class HomeTheaterTestDrive {

    public static void main(String[] args) {
        // 구성 요소 초기화
        // 지금은 구성 요소를 직접 생성하지만 보통은 클라이언트에 퍼사드가 주어지므로 직접 구성 요소를 생성하지 않아도 된다.

        Amplifier amp = new Amplifier();
        Tuner tuner = new Tuner();
        StreamingPlayer player = new StreamingPlayer();
        Projector projector = new Projector();
        TheaterLights lights = new TheaterLights();
        Screen screen = new Screen();
        PopcornPopper popper = new PopcornPopper();
        HomeTheaterFacade homeTheater = new HomeTheaterFacade(
            amp,
            tuner,
            player,
            projector,
            lights,
            screen,
            popper
        );
        // 단순화된 인터페이스를 사용
        homeTheater.watchMovie("king kong");
        homeTheater.endMovie();
    }

}

핵심정리

✅ 기존 클래스를 사용하려고 하는데 인터페이스가 맞지 않으면 어댑터를 쓰면 된다.

✅ 큰 인터페이스와 여러 인터페이스를 단순하게 바꾸거나 통합해야 하면 퍼사드를 쓰면 된다.

✅ 어댑터는 인터페이스를 클라이언트에서 원하는 인터페이스로 바꾸는 역할을 한다.

✅ 퍼사드는 클라이언트를 복잡한 서브시스템과 분리하는 역할을 한다.

✅ 어댑터를 구현할 때는 타깃 인터페이스의 크기와 구조에 따라 코딩해야 할 분량이 결정된다.

✅ 퍼사드 패턴에서드는 서브시스템으로 퍼사드를 만들고 진짜 작업은 서브클래스에 맡긴다.

✅ 어댑터 패턴에는 객체 어댑터 패턴과 클래스 어댑터 패턴이 있다.

➡️ 클래스 어댑터를 사용하려면 다중 상속이 가능해야 한다.

✅ 한 서브시스템에 퍼사드를 여러 개 만들어도 된다.

✅ 어댑터는 객체를 감싸서 인터페이스를 바꾸는 용도로, 데코레이터는 객체를 감싸서 새로운 행동을 추가하는 용도로, 퍼사드는 일련의 객체를 감싸서 단순하게 만드는 용도로 쓰인다.

[뉴스뭉 ] 1. 슬랙봇으로 학교 공지 알림서비스를 만든다고?

솔라솔 — Thu, 30 Nov 2023 12:34:12 +0900

☀️ 인트로

안녕하세요.솔라솔입니다.

오늘은 제가 스스로 불편해서 만들고자 한 "학교, 학과 공지 알림 슬랙봇 만들기- 뉴스뭉" 을 개발하게 된 이유를 설명하고자 합니다.

☀️ 서론

이상하게 프로그래밍 언어론 수업시간마다 이상한 아이디어들이 떠올라서..(교수님 죄송합니다.)

지난번엔 갑자기 github.io를 만들었고, 오늘은 갑자기 슬랙봇개발에 꽂혀버렸네요.

그치만 이게 바로 개발의 재미인 것 같기도 합니다.

" 내가 ~~이러한 점이 불편하다! -> 만들어보자!"

가 되는 재미가 개발 말고 또 있을까요?

뉴스뭉 은 상명대학교 웹페이지의 공지사항 변화를 포착해 슬랙 채널로 메시지를 보내주는 서비스이다.

새로운 공지사항이 올라오면 1분 안에 알려주고, 무료이다

지인 대상으로 시작해서 일반공지/학사공지/장학공지/컴퓨터과학과 주요공지/ 컴퓨터과학과 취업,인턴십공지 등의 채널을 운영할 생각이며, 차차 타과 공지 게시판,취업플랫폼, 공모전 관련 플랫폼 등의 공지를 긁어올 예정이다.

☀️ 기획 의도

왜 만들었다고?

내가 너무 불편해서, 그리고 친구들도 다같이 써보면 좋을 것 같아서 만들기로 했다.

개인적으로 생각했을때 우리학교의 경우 커뮤니티적인 성격이 약하다. 서로 이끌어주고, 이끌리고의 느낌이 없달까? (개인적인 의견이다)

개인플레이적인 성격이 강한 것이 아쉬웠다. 지인 중에 서강대 친구가 있는데, 그 친구가 그때 보여준게 바로 서강대 슬랙봇이다.

그때 봤던건 아마도 https://www.acmicpc.net/ 백준님이 제공해주는 서강대 정보제공 슬랙봇(이었던 것 같다.

슬랙 내에서 서로 이끌고 이끌어주는 시스템이 부러웠다.

우리학교에도 적어도 좋은것을 함께 공유하는 시스템이 생기면 좋겠다고 생각했다.

'학교' 즐겨찾기

처음에는 학교 관련 홈페이지들을 다 즐겨찾기에 넣어서 "학교" 로 처리해두고 가급적 매일 봤다. 그치만,학년이 올라가면서, 취업정보도 다른 곳에서 봐야하고, 확인해야할 사이트들이 많아졌다.

'매일확인' 즐겨찾기

그래서 매일확인 즐겨찾기를 새로 만들었다.

통합공지 -> 학과 상관없이 통합공지가 올라오는 곳

컴과 -> 컴퓨터과학과 공지가 올라오는 곳

SW중심사업단 -> 이 홈페이지를 모르는 친구들이 많은 것 같은데, 인턴이나 취업 등 학교에서 제공해주는 공모전 같은게 많이 올라오는 사이트이다.

개인적으로 학년이 올라갈수록 학교에서 제공해주는 공모전이나 활동들을 다 뽑아먹자! 라는 생각을 가지고 학교를 다녔기 때문에, 이 사이트가 매우 중요하다고 생각되었다.

인턴 사이트 -> 링커리어에 들어가게 되면 직무 'IT/인터넷 ', 나의 경우 '서울/경기'로 모집요강을 자주 확인하곤 했다.

나머지 사이트들은 개인적으로 필요한 것들을 즐겨찾기 하며 지속적으로 확인하고자 하였다.

그러다 보니까, 내가 너무 불편한거다!

" 왜 내가 스스로 이걸 하나하나 누르면서 확인해야하지? 이걸 통합적으로 자동화 시킬 수는 없나? "

라는 생각이 문득 떠올랐다.

생각이 떠오르면 냅다 만들고 보는 편이다.

슬랙을 고른 이유?

슬랙의 경우, 예전에 CJ UNIT에서 활동할때 써본 경험이 있었다. AWS 경진대회때도 사용했다.

내가 크롤링해서 가져올 생각은 못했는데, 이번기회에 가져와보자 했다.

~~참고로 지금은 시험 3주전이다.~~

UMC 활동할때는 디스코드에서 노래하는 하리보봇이나 이런것들로 유튜브 뮤직을 끌어오곤 했다.

디스코드랑 슬랙 둘다 사용해봐서, 처음엔 조금 고민이 되었다.

둘 중에 뭐쓰지?

https://greypencil.tistory.com/145

개발자들은 왜 Slack 을 쓸까?

"카카오톡 쓰면 안되나요?" "디스코드 쓰면 안되나요?" 정답은 이렇다. "안돼요 !!!" 좀 이상하다. 개발자들은 왜 꼭 Slack 을 써야 할까? 채팅이라면 카카오톡이 더 편하다. 초대하기가 더 쉽기 때문

greypencil.tistory.com

이 글을 보기도 했고, 나에게 디스코드는 조금더 게임의 느낌이라면, 슬랙은 그저 "업무용"의 느낌이었다.

뉴스뭉 개발기 이제 시작~

뉴스(클리핑) + 스뭉(수뭉)을 합쳤다.

언제 개발이 완료될지는 모르겠지만 상당히 새로운 걸 기획하고 개발해나가는건 설레는 일이다.

빨리 개발해서 얼른 새로운 "아키텍쳐와 알고리즘"을 담은 새로운 글을 작성해오겠다!

* 비밀댓글을 통한 문의는 받지 않고 있습니다. 공개댓글로 남겨주세요!
조금이라도 도움이 되었다면, 공감/댓글을 남겨주시면 솔라솔에게 매우 큰 힘이 될 것 같습니다!
댓글은 언제나 환영입니다!

[업보청산 캡스톤] - 교수님 첫 면담 회고

솔라솔 — Wed, 29 Nov 2023 15:16:39 +0900

안녕하세요.솔라솔입니다.

제 졸프팀인, 업보청산캡스톤(아직 가명) 팀의 졸업프로젝트가 시작되었는데요.

오늘은 이 프로젝트의 기획의도 및 면담 회고에 대해 작성해보려고 합니다.

아마, [업보청산 캡스톤] 의 글은 차차 프로젝트가 진행되는대로 글이 더 추가될 것 같습니다.

☀️ 기획

단순한 프로젝트가 아니라, "졸업 프로젝트"를 진행함에 있어 우리 팀원이 얻어갈 수 있는 가장 큰 장점이 무엇일까 생각해보았습니다.

제가 생각했을때는 "사용자 유치 경험" 이었습니다.

학교 관련 서비스를 만들면 프로젝트에 있어 가장 큰 어려움 중 하나인 "사용자 유치" 및 "사용자 증가로 인한 이슈 해결" 들을 경험해볼 수 있지 않을까 ? 하는 생각으로 시작되었습니다.

제가 그동안 진행해온 다양한 동아리에서의 프로젝트들은 물론 아이디어가 좋은 것들이 많았으나, 실제로 개발하여 배포까지 완성하여도, 사용자가 많이 없어서 그로인한 이슈발생하는 것들을 경험해보지 못하는건 아쉬웠기 때문입니다.

저희 학교의 경우 (특히 컴퓨터과학과) 졸업요건이 까다롭습니다.
현 2023.12월 기준, 컴퓨터과학과 전공생의 졸업요건 중 "공학인증 필수"는 제외되었으나, 기존에는 공학인증은 필수였습니다.

공학인증제도를 따르려면 전공심화 과목 00개, 수학과목 00개, 설계 과목 00개 등 매우 복잡한 커리큘럼을 학생 스스로 따라야하는게 문제점이었습니다.

현 2023.12월 기준으로는 이 제도를 필수적으로 따라야하는게 폐지되었으나, 기존에 따르던 학생들은 이학사가 아닌 공학사를 딸 수 있는 기회를 놓칠 이유가 없기에 아직까지는 많은 학우들이 공학인증제도를 따르는것으로 알고 있습니다.

따라서, 공학인증제도나, 개인의 졸업요건에 맞춰 자동으로 시간표를 만들어주는 프로그램을 짜보면 어떨까? 하는 생각을 하였습니다.

첫 기획안

처음 교수님께 이메일로 컨택했을때는 "백엔드의 기능이 부족한 것 같아요. 이정도 규모면 백엔드가 굳이 필요할까요?" , "기능 추가가 필요할 것 같습니다" 라는 피드백을 받았습니다.

"기능 추가"가 도대체 무슨말씀이실까 하는 생각에 도무지 생각이 안나던 저희팀이었는데요(심지어 주제를 바꿔야하나 하는 생각도 했습니다), 면담결과 방향성을 깨닫게 되었습니다.

팀원들이 그래도 개발 프로젝트 경험이 있는 친구들이라 "죽어도 커뮤니티 기능은 안 넣고 싶다" 라는 생각이 많았는데요, 커뮤니티 기능이 아니더라도 사용자간의 상호작용이 가능한 백엔드의 기능들을 추가적으로 생각이 가능하겠더라구요.

*** reference

가천대 시간표 조합봇

처음에는 가천대 시간표 조합봇 처럼 챗봇 형태로 개발하고자 하였으나, 저희 팀 프론트엔드 팀원들은 iOS 개발 친구들이기에 앱개발로 틀었습니다.

☀️ 교수님과 첫 면담 회고

당분간은 주제를 바꿀 생각을 하지 않는 방향으로. 지금 주제를 어떻게 하면 더 키울 수 있을지 고민하세요
사용자간의 상호작용을 할 수 있는 방향으로 백엔드의 기능을 추가하세요
- 백엔드에서 추가되어야하는 기능 : 새로운 정보들이 추가되고 삭제되는게 자주 일어나는 것
1. 사용자 간의 영향이 끼치는 ‘시간표 공유 비교 ’ 같은 기능, ‘담은 사람’ 기능 등 → 이런건 필수. 이걸 더 고민해보자
  1. 하루에 몇명이 추가했는지 기록을 남겨서 몇 명 담았는지 등등
2. 게시판 류 (마켓,거래,채팅 등등) → 이건 아직 보류긴함 (최후의 수단)
목적을 ‘장바구니 기간 1~2주 간’의 서비스 느낌으로
- 수강신청이 2/10에 시작한다면 2.1부터 서비스 오픈
  - 아마 저희 프로젝트는 겨울방학~7,8월 개발 후 , 8월 장바구니 기간에 서버 테스트를 할 수 있을 것 같다고 예상합니다.
- 학교에서 제공하는 실제 수강신청은 배제하고 생각하세요(실제 수강신청은 사용자의 몫)
교수님의 요청사항:
- 단톡방을 만드세요
- 협업툴 링크 공유 해주세요
- 회의하면, 회의록 링크만 카톡방에 공유해주세요
- 일주일에 한번 우리끼리 만나는건 이렇게 유지하고,
  - 교수님이랑은 단톡방에서 약속 을 잡아서 일정짜서 잡고 줌으로 해도 되고(안되면)
  - 이번학기에는 다같이 (교수님포함) 만날수있는 시간이 많을 거 같지 않음
- 아이디어를 낼때, 자유롭게 받으세요.

☀️ 앞으로의 계획은?

앞으로 다양한 "사용자 간의 상호작용"이 가능한 백엔드의 기능을 추가할 것 같습니다. (추가되고, 정리되는대로 티스토리에도 글을 올려 공유하겠습니다)

사용자 유치 에 초점을 맞춘다면, 더할 나위 없이 좋은 프로젝트 기획안이라고 생각됩니다. 되도록이면 주제를 바꾸지 않고 쭉 진행하고자 합니다.
차차 기획안을 다시 정리하고, 기말고사가 끝난 뒤부터 개발을 진행하도록 하겠습니다~!! 지켜봐주세요

* 비밀댓글을 통한 문의는 받지 않고 있습니다. 공개댓글로 남겨주세요!
조금이라도 도움이 되었다면, 공감/댓글을 남겨주시면 솔라솔에게 매우 큰 힘이 될 것 같습니다!
댓글은 언제나 환영입니다!

[시스템소프트웨어] 2. Loop

솔라솔 — Wed, 29 Nov 2023 08:18:26 +0900

안녕하세요. 솔라솔입니다.

1. ASM IO 라이브러리에는 문자열을 입력 받는 루틴은 포함되어 있지 않다. 문자열을 입력 받는 프로그램 read_string.asm 을 작성하시오. 이 프로그램은 (1) 엔터 키가 눌릴 때까지 read_char 루틴을 반복 호출하여 문자열을 입력 받고, (2) 이를 개행 문자를 제외한 null-terminated 문자열로 저장한 후, (3) 문자열이 제대로 입력, 저장되었는지 확인하기 위해 print_string 루틴을 사용하여 입력 받은 문자열을 출력해야 한다. 이 프로그램을 어셈블, 링크하여 실행 파일 read_string 을 생성하고, 이를 임의의 문자열 입력을 주어 실행시킨 결과를 화면 캡쳐 하여 첨부하시오. 또한 작성한 소스 코드도 화면 캡쳐하여 첨부하시오. 단, 아래의 코드를 활용해도 좋으나 입력 문자열의 길이가 저장 공간의 크기를 넘어가지 않도록 수정하여 사용하시오.

…

	segment .bss
string	resb	32	; 마지막 null 문자를 포함한
			; 입력 문자열의 최대 길이


	segment .text

	…
	mov	edx, 0
repeat:	call	read_char
	mov	[string+edx], al
	inc	edx
	cmp	al, 0x0a		; 엔터가 눌릴 때까지
	jne	repeat		; 반복 입력
	mov	byte [string+edx-1], 0	; 마지막 개행문자는
					; null 문자로 대체
	
	…

2. (mult.asm) 두 수를 입력 받아, 덧셈을 반복하는 방식으로 두 수의 곱을 계산하여 결과를 출력하는 프로그램 mult.asm 을 작성하시오 (즉 2 x 4 = 2 + 2 + 2 + 2 형태로 계산). 이 프로그램을 어셈블, 링크하여 실행 파일 mult 을 생성하고, 이를 실행시킨 결과를 화면 캡쳐 하여 첨부하시오. 또한 작성한 소스 코드도 화면 캡쳐하여 첨부하시오.

- 곱하는 두 수의 입력은 read_int 루틴을 사용한다.

- 결과값의 출력은 print_int 루틴을 사용

- 루프는 반드시 loop 명령을 사용하여 구현

3. (atoi.asm) 사용자로부터 십진수 문자만으로 이루어진 문자열(‘0’ ~ ‘9’로만 이루어진 문자열)을 입력 받고, 이를 해당 정수로 변환하는 프로그램 atoi.asm 을 작성하시오. 이 프로그램을 어셈블, 링크하여 실행 파일 atoi 를 생성하고, 이를 실행시킨 결과를 화면 캡쳐 하여 첨부하시오. 또한 작성한 소스 코드도 화면 캡쳐하여 첨부하시오.

- ASM IO 라이브러리의 read_int 루틴은 사용할 수 없다; 문제 2번과 같이 반드시 read_char 를 반복 호출하는 형태이어야 함.

- 십진수 1234 의 경우, 1234 = 1x103 + 2x102 + 3x101 + 4x100 = (((((0+1) x 10) + 2) x 10) + 3) x 10 +4 임을 활용한다.

- 문자 ‘0’의 ASCII 코드 값은 0x30, 문자 ‘1’의 값은 0x31, …, 문자 ‘9’의 값은 0x39 이다.

- 숫자 변환이 제대로 되었는지 확인하기 위해 print_int 루틴을 사용하여 계산된 숫자값을 출력해 보도록 한다.

디자인패턴 정리 - DAO 과제 실습

솔라솔 — Tue, 28 Nov 2023 09:25:41 +0900

☀️ 인트로

안녕하세요 솔라솔입니다.

오늘은 과제였던 DAO 패턴 과제를 정리해보도록 하겠습니다.

☀️ 과제-1.DAO 패턴

웹사이트의 아이디와 비밀번호를 관리하는 프로그램 을 DAO 패턴을 이용해서 작성

웹사이트 URL, 아이디, 비밀번호를 DB에 저장, 수정, 삭제 및 검색 가능

Sqlite를 이용해서 다음에 해당되는 테이블 생성

Db파일 이름과 테이블 이름은 본인이 결정

main()에서 할 일

다음 데이터를 DB에 추가

https://www.smu.ac.kr, "smu", "abcde"

https://www.smu2.ac.kr, "smu2", "abcde"

데이터가 제대로 추가되었는지 모든 데이터를 출력해서 확인(SELECT로 확인)

두 번째 데이터의 id인 "smu2"를 "smu1"으로 수정

해당 데이터가 제대로 수정되었는지 데이터를 출력해서 확인(SELECT로 확인)

"https://www.smu2.ac.kr" 데이터 삭제(key로 삭제)

전체 데이터 출력해서 데이터가 제대로 삭제되었는지 확인

public class PasswordInfo {
private String url;
private String id;
private String password;
PasswordInfo(String url, String id, String pw){
this.url = url;
this.id = id;
this.password = pw;
}
public String toString() {
return "" + url + ", " + id + ", " + password;
}
public String getUrl() { return url; }
public void setName(String url) { this.url = url; }
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getPassword() { return password; }
public void setPassword(String pw) {
this.password = pw;
}
}

DAO 인터페이스

import java.util.List;
public interface PasswordDAO {
public void insert(PasswordInfo p);
public List<PasswordInfo> findAll();
public PasswordInfo findByKey(String url);
public void update(PasswordInfo p);
public void delete(String url);
public void delete(PasswordInfo p);
}

☀️ 실습진행

PassWordInfo 먼저 만들고

기존에 있던 address 내용과 passwordinfo 를 바탕으로 일반화 시킨 class 생성

generics 이용해서 일반화된 DAO 만들기

이걸 이용해서 Passwordinfo 다시 수정하는 과정을 거칠것임

AddressBook 의코드와 흡사하기때문에 이를 쓸 예정

Person이었던 애들을 PassWordInfo 로 바꾼다

FindById 를 FindByKey 로 수정

수정한 PasswordDAO.java

import java.util.List;

public interface PasswordDAO {
    public void insert(PasswordInfo p);
    public List<PasswordInfo> findAll();
    public PasswordInfo findByKey(String Key);
    public void update(PasswordInfo p);
    public void delete(String key);
    public void delete(PasswordInfo p);
}

수정한 PassWordDaoImpl.java

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

public class PassWordDaoImpl implements PaswwordDAO {
    final static String DB_FILE_NAME = "passwords.db";
    final static String DB_TABLE_NAME = "paswords";

    Connection connection = null;
    ResultSet rs = null;
    Statement statement = null;

    public PassWordDaoImpl() {
        try {
            connection = DriverManager.getConnection("jdbc:sqlite:" + DB_FILE_NAME);
            statement = connection.createStatement();
            statement.setQueryTimeout(30);  // set timeout to 30 sec.
            final String table = " (URL text PRIMARY KEY AUTOINCREMENT, id text, password text)";

            // create table
            statement.executeUpdate("DROP TABLE IF EXISTS " + DB_TABLE_NAME);
            statement.executeUpdate("CREATE TABLE " + DB_TABLE_NAME + table);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void insert(PassWordInfo p) {
        try {
            String fmt = "INSERT INTO %s VALUES('%s', '%s', '%s')";
            String q = String.format(fmt, DB_TABLE_NAME, p.getURL(), p.getId(), p.getPassword());
            
            statement.execute(q);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public List<PassWordInfo> findAll() {
        ArrayList<PassWordInfo> PassWordInfos = new ArrayList<PassWordInfo>();
        try {
            rs = statement.executeQuery("SELECT * FROM " + DB_TABLE_NAME);
            while (rs.next()) {
                PassWordInfos.add(new PassWordInfo(rs.getString("url"), rs.getString("id"),
                                       rs.getString("password")));
            }
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return PassWordInfos;
    }

    public PassWordInfo findByKey(String key) {
        PassWordInfo passWordInfo = null;
        try {
            String fmt = "SELECT * FROM %s WHERE url = '%s'";
            String q = String.format(fmt, DB_TABLE_NAME, key);
            rs = statement.executeQuery(q);
            if (rs.next()) {
                PassWordInfo = new PassWordInfo(rs.getString("url"), rs.getString("id"),
                                   rs.getString("password"));
            }
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return PassWordInfo;
    }

    public void update(PassWordInfo p) {
        //PassWordInfo PassWordInfo = findByKey(p.getUrl());
        if (p != null) {
            try {
                String fmt = "UPDATE %s SET id = '%s', password = '%s' WHERE url = %s";
                String q = String.format(fmt, DB_TABLE_NAME, p.getId(), p.getPassword(), p.getUrl());
                
                statement.execute(q);
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public void delete(String Key) {
        try {
            String fmt = "DELETE FROM %s WHERE url = '%s'";
            String q = String.format(fmt, DB_TABLE_NAME, key);
            
            statement.execute(q);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void delete(PassWordInfo p) {
        delete(p.getUrl());
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        PasswordInfo p;
        PasswordDao PasswordInfoDao = new PasswordDaoImpl();

        System.out.println("--- inserting...");
        p = new PasswordInfo("https://www.smu.ac.kr", "smu", "abcde");
        PasswordInfoDao.insert(p);
        p = new PasswordInfo("https://www.smu2.ac.kr", "smu2", "abcde");
        PasswordInfoDao.insert(p);

        System.out.println("--- finding all...");
        for (PasswordInfo pi : PasswordInfoDao.findAll()) {
            System.out.println("reading... " + pi);
        }

        System.out.println("--- updating...");
        p = PasswordInfoDao.findAll().get(1);
        p.setId("smu1");
        PasswordInfoDao.update(p);

        System.out.println("--- see if updated...");
        p = PasswordInfoDao.findByKey("https://www.smu2.ac.kr");
        if (p != null) {
            System.out.println(p);
        }

        System.out.println("--- deleting...");
        PasswordInfoDao.delete("https://www.smu2.ac.kr");  // or PasswordInfoDao.delete(p);

        System.out.println("--- finding all after deleting...");
        for (PasswordInfo pi : PasswordInfoDao.findAll()) {
            System.out.println("reading... " + pi);
        }
    }
}

Main.java Run한 결과

☀️ 과제-2. 뜯어 고쳐서 Generics 화

Dao.java 인터페이스

import java.util.List;

public interface Dao<D extends Data<K>, K> {
    public void insert(D p);
    public List<D> findAll();
    public D findByKey(K key);
    public void update(D p);
    public void deleteByKey(K key);
    public void deleteByData(D p);
}

DaoImpl.java

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

public abstract class DaoImpl<D extends Data<K>, K> implements Dao<D, K> {
    public abstract String getDBFileName();
    public abstract String getTableName();
    public abstract String getTableCreationString();
    public abstract String getInsertString(D p);
    public abstract D getNewInstance(ResultSet rs);
    public abstract String getKeyColumnName();
    public abstract String getUpdateString(D p);

    Connection connection = null;
    ResultSet rs = null;
    Statement statement = null;

    public DaoImpl() {
        try {
            connection = DriverManager.getConnection("jdbc:sqlite:" + getDBFileName());
            statement = connection.createStatement();
            statement.setQueryTimeout(30);  // set timeout to 30 sec.
            // create table
            statement.executeUpdate("DROP TABLE IF EXISTS " + getTableName());
            statement.executeUpdate("CREATE TABLE " + getTableName() + getTableCreationString());
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void insert(D p) {
        try {
            String fmt = "INSERT INTO %s VALUES(%s)";
            String q = String.format(fmt, getTableName(), getInsertString(p));

            statement.execute(q);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public List<D> findAll() {
        ArrayList<D> lst = new ArrayList<D>();
        try {
            rs = statement.executeQuery("SELECT * FROM " + getTableName());
            while (rs.next()) {
                lst.add(getNewInstance(rs));
            }
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return lst;
    }

    public D findByKey(K key) {
        D d = null;
        try {
            String fmt = "SELECT * FROM %s WHERE %s = '%s'";
            String q = String.format(fmt, getTableName(), getKeyColumnName(), key);
            rs = statement.executeQuery(q);
            if (rs.next()) {
                d = getNewInstance(rs);
            }
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return d;
    }

    public void update(D p) {
        if (p != null) {
            try {
                String fmt = "UPDATE %s SET %s WHERE %s = '%s'";
                String q = String.format(fmt, getTableName(), getUpdateString(p), getKeyColumnName(), p.getKey());

                statement.execute(q);
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public void deleteByKey(K key) {
        try {
            String fmt = "DELETE FROM %s WHERE %s = '%s'";
            String q = String.format(fmt, getTableName(), getKeyColumnName(), key);

            statement.execute(q);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void deleteByData(D p) {
        deleteByKey(p.getKey());
    }
}

Data.java 인터페이스

public interface Data<K> {
    K getKey();
}

를 추가한다.

디자인패턴 정리 - DAO 패턴

솔라솔 — Mon, 27 Nov 2023 12:30:18 +0900

안녕하세요. 솔라솔입니다.

고급객체지향프로그래밍 전공 수업도중 배운 DAO 패턴에 대해 정리해보려 합니다. DAO 패턴의 경우 데이터베이스 전공 수업 도중 배운 내용들과 연관이 깊은 것 같아 비교적 쉽게 이해할 수 있었습니다.

아마 여러분들 중에도 데이터베이스 수업을 수강하셨던 분들은 DAO 패턴에는 큰 어려움이 없으실 것이라 예상합니다.

☀️ DAO 패턴이란

(Data Access Object) 패턴

목적: 비즈니스로직(업무) 와 DBMS 를 분리하기 위해 사용

업무와 데이터 2계층을 분리하고, 서로 그 상태를 동일하게 유지 (persisetence)

문제: DB 를 사용하는 방법이 변경되면 클라이언트의 수정이 많아진다.
- 데이터를 저장하는 방식이 다양하다.(데이터베이스, 파일,XML, csv파일 등)
- 사용하는 방법이 다르면 변경 부분이 많아진다.(ex. DBMS 에 따라 SQL 문이 다를 수 있음)
해결방안: 사용 방법을 분리 시킨다.
- 데이터를 저장하는 방식을 분리하여, 변경부분을 최소화 시킨다.
결과: loose coupling, 확장성

☀️ 사례1. 주소록

CRUD(Create, Read, Update, Delete)를 구현

주소록 관리

사용자가 데이터베이스를 생성하고 데이터를 입력

수정 요청(데이터가 존재하는지 확인)

삭제 요청(데이터가 존재하는지 확인)

세가지 버전으로 개발

1. AddressBookWithoutDao -> 막 코딩한 버전

DAO 패턴 사용하지 않고 직접 DB를 조작.

데이터베이스는 Sqlite 사용

데이터베이스 파일이름 (AddressBoo.db)

테이블 구조 (Table name: persons)

2. AddressBookWithList -> 메모리에 저장

DAO 패턴을 사용하지만, DB를 사용하는 것이 아니고, ArrayList를 이용해서 개발

3. AddressBookWithDao -> DB 이용 버전

DAO 패턴과 DB를 이용해서 개발

☀️ 1) AddressBookWithoutDao

DAO 패턴 사용하지 않고 직접 DB를 조작.

데이터베이스는 Sqlite 사용

데이터베이스 파일이름 (AddressBoo.db)

테이블 구조 (Table name: persons)

** 참고) JDBC

데이터베이스 비종속적인 표준 자바 API
- 다양한 데이터베이스를 동일한 인터페이스로 사용할 수 있도록 함
- 각종 데이터베이스는 JDBC Driver를 통해서 연결하고 사 용
주 사용 방법
- 데이터베이스에 연결
- SQL 쿼리 작성 후 데이터베이스에서 실행
- 결과로 반환되는 데이터를 수정하거나 화면에 출력

코드를 만져보자!

src 코드 옮긴 뒤에

Project Structure 선택 후

sqlite 를 libraries 에 추가한다

import java.sql.*;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class AddressBookWithoutDAO {
    final static String DB_FILE_NAME = "addressbook.db";
    final static String DB_TABLE_NAME = "persons";

    public static void main (String[] args){
        Connection connection = null;
        ResultSet rs = null;
        Statement statement = null;
        try {
            connection = DriverManager.getConnection(
                    "jdbc:sqlite:" + DB_FILE_NAME);
            statement = connection.createStatement();
            statement.setQueryTimeout(30);

            final String table = " (ID INTEGER PRIMARY KEY AUTOINCREMENT, name text, address text)";

            // create table
            statement.executeUpdate(
                    "DROP TABLE IF EXISTS " + DB_TABLE_NAME);
            statement.executeUpdate(
                    "CREATE TABLE " + DB_TABLE_NAME + table);

            System.out.println("--- inserting...");
            statement.execute("INSERT INTO persons(name, address) VALUES('Seonyoung Kim','1 Hongji Dong')");
            statement.execute("INSERT INTO persons(name, address) VALUES('Jangkwon Lee','2 Hongji Dong')");
            System.out.println("--- finding all...");
            rs = statement.executeQuery(
                    "SELECT * FROM persons");// WHERE id < 4 ORDER BY id");
            while (rs.next()) {
                System.out.println(
                        "" + rs.getInt("ID") + ", "
                                + rs.getString("name") + ", "
                                + rs.getString("address"));
            }

            System.out.println("--- updating...");
            statement.execute(
                    "UPDATE persons SET name = 'Sooyoung Lim' WHERE id = 1");

            System.out.println("--- see if updated...");
            rs = statement.executeQuery(
                    "SELECT * FROM persons WHERE id = 1");
            while (rs.next()) {
                System.out.println(rs.getInt("id") + ", "
                        + rs.getString("name") + ", "
                        + rs.getString("address"));
            }
            System.out.println("--- deleting...");
            statement.execute(
                    "DELETE FROM persons WHERE id = 1");

            System.out.println("--- finding all after deleting...");
            rs = statement.executeQuery(
                    "SELECT * FROM persons WHERE id < 4 ORDER BY id");
            while (rs.next()) {
                System.out.println(rs.getInt("id") + ", "
                        + rs.getString("name") + ", "
                        + rs.getString("address"));
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }
        finally {
            try {
                if (rs != null) { rs.close(); }
                if (statement != null) { statement.close(); }
                if (connection != null) { connection.close(); }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    } // main
} // class

위 코드 run 시 다음과 같은 결과가 나온다.

AddressBookWithMySQLDB.java

/* 실행 전에 MySQL 또는 MariaDB가 설치되어 있어야 함
   MySql client를 실행시켜서 다음 명령어 실행
   0. c:\>mysql -u root -p
   Enter password: *******  <-- root 비밀번호 입력   
   1. MySQL(또는 MariaDB)에 addruser와 addrpw를 추가
   mysql> create user 'addruser'@'localhost' identified by 'addrpw';
   2. Database 생성
   mysql> create database AddressBook;
   3. addruser가 생성된 데이터베이스에 접근할 수 있도록 지정
   mysql> grant all privileges on *.* to 'addruser'@'localhost';
   mysql> grant all privileges on AddressBook.* to 'addruser'@'localhost';
   mysql> flush privileges;
   mysql> exit
*/

import java.sql.*;

public class AddressBookWithMySQLDB {
//    static final String MARIA_DB_JDBC_DRIVER = "org.mariadb.jdbc.Driver"; // MariaDB driver
    static final String MYSQL_JDBC_DRIVER = "com.mysql.cj.jdbc.Driver"; // MySQL driver
    static final String DB_NAME = "AddressBook";
    static final String DB_FILE_NAME = "addressbook.db";
    static final String DB_TABLE_NAME = "persons";

    static final String USERNAME = "addruser";
    static final String PASSWORD = "addrpw";

    public static void main (String[] args){
        Connection connection = null;
        ResultSet rs = null;
        Statement statement = null;
        try {
//            Class.forName(MARIA_DB_JDBC_DRIVER); // loading a JDBC driver
            Class.forName(MYSQL_JDBC_DRIVER); // loading a JDBC driver
            //        connection = DriverManager.getConnection("jdbc:mariadb://localhost:3306/" + DB_NAME, USERNAME,  PASSWORD);
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/" + DB_NAME, USERNAME,  PASSWORD);  // MySQL
            statement = connection.createStatement();
            statement.setQueryTimeout(30);  // set timeout to 30 sec.

            final String table = " (id int(64) NOT NULL AUTO_INCREMENT, name varchar(255) NOT NULL, address varchar(255) NOT NULL, UNIQUE(id))";
            // create table
            statement.executeUpdate("DROP TABLE IF EXISTS " + DB_TABLE_NAME);
            statement.executeUpdate("CREATE TABLE " + DB_TABLE_NAME + table);

            System.out.println("--- inserting...");
            statement.execute("INSERT INTO persons(name, address) VALUES('Seonyoung Kim','1 Hongji Dong')");
            statement.execute("INSERT INTO persons(name, address) VALUES('Jangkwon Lee','2 Hongji Dong')");

            System.out.println("--- finding all...");
            rs = statement.executeQuery("SELECT * FROM persons WHERE id < 4 ORDER BY id");
            while (rs.next()) {
                System.out.println("" + rs.getInt("ID") + ", " + rs.getString("name") + ", " + rs.getString("address"));
            }

            System.out.println("--- updating...");
            statement.execute("UPDATE persons SET name = 'Sooyoung Lim' WHERE id = 1");

            System.out.println("--- see if updated...");
            rs = statement.executeQuery("SELECT * FROM persons WHERE id = 1");
            while (rs.next()) {
                System.out.println(rs.getInt("id") + ", " + rs.getString("name") + ", " + rs.getString("address"));
            }

            System.out.println("--- deleting...");
            statement.execute("DELETE FROM persons WHERE id = 1");

            System.out.println("--- finding all after deleting...");
            rs = statement.executeQuery("SELECT * FROM persons WHERE id < 4 ORDER BY id");
            while (rs.next()) {
                System.out.println(rs.getInt("id") + ", " + rs.getString("name") + ", " + rs.getString("address"));
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }
        finally {
            try {
                if(rs != null) {
                    rs.close();
                }
                if(statement != null) {
                    statement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

☀️ 2) AddressBookWithList

DAO 패턴을 사용하지만, DB를 사용하는 것이 아니고, ArrayList를 이용해서 개발

DAO 인터페이스

import java.util.List;

public interface PersonDao {
    public void insert(Person p);
    public List<Person> findAll();
    public Person findById(int id);
    public void update(int id, Person p);
    public void delete(int id);
    public void delete(Person p);
}

Person.java

public class Person {
    private static int counter = 1;
    private int id;
    private String name;
    private String address;
    
    Person(String name, String address) {
        this.name = name;
        this.address = address;
        id = counter;
        counter++;
    }

    Person(int id, String name, String address) {
        this.name = name;
        this.address = address;
        this.id = id;
    }

    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }
    
    public void setId(int id) {
        this.id = id;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "" + id + ", " + name + ", " + address;
    }
}

PersonDaoImpl.java

import java.util.ArrayList;
import java.util.List;

public class PersonDaoImpl implements PersonDao {
    List<Person> persons;

    public PersonDaoImpl() {
        persons = new ArrayList<Person>();
    }

    public void insert(Person p) {
        persons.add(p);
    }

    public List<Person> findAll() {
        return persons;
    }

    public Person findById(int id) {
        for (Person pi : persons) {
            if (pi.getId() == id) {
                return pi;
            }
        }
        return null;
    }

    public void update(int id, Person p) {
        Person person = findById(id);
        if (person != null) {
            person.setName(p.getName());
            person.setAddress(p.getAddress());
        }
    }

    public void delete(int id) {
        Person person = findById(id);
        if (person != null) {
            persons.remove(person);
        }
    }

    public void delete(Person p) {
        persons.remove(p);
    }
}

Address.java

public class AddressBook {
    public static void main(String[] args) {
        Person p;
        PersonDao personDao = new PersonDaoImpl();

        System.out.println("--- inserting...");
        p = new Person("Seonyoung Kim", "1 Hongji Dong");
        personDao.insert(p);
        p = new Person("Jangkwon Lee", "2 Hongji Dong");
        personDao.insert(p);

        System.out.println("--- finding all...");
        for (Person pi : personDao.findAll()) {
            System.out.println("reading... " + pi);
        }

        System.out.println("--- updating...");
        p = personDao.findAll().get(0);
        p.setName("Sooyoung Lim");
        personDao.update(p.getId(), p);

        System.out.println("--- see if updated...");
        p = personDao.findById(1);
        if (p != null) {
            System.out.println(p);
        }

        System.out.println("--- deleting...");
        personDao.delete(1);  // or personDao.delete(p);

        System.out.println("--- finding all after deleting...");
        for (Person pi : personDao.findAll()) {
            System.out.println("reading... " + pi);
        }
    }
}

☀️ 3) AddressBookWithDao

DAO 패턴과 DB를 이용해서 개발

DAO 인터페이스

Person 클래스의 CRUD 를 마찬가지로 지정

import java.util.List;

public interface PersonDao {
    public void insert(Person p);
    public List<Person> findAll();
    public Person findById(int id);
    public void update(int id, Person p);
    public void delete(int id);
    public void delete(Person p);
}

PersonDaoImpl.java

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

public class PersonDaoImpl implements PersonDao {
    final static String DB_FILE_NAME = "addrbook.db";
    final static String DB_TABLE_NAME = "persons";

    Connection connection = null;
    ResultSet rs = null;
    Statement statement = null;

    public PersonDaoImpl() {
        try {
            connection = DriverManager.getConnection("jdbc:sqlite:" + DB_FILE_NAME);
            statement = connection.createStatement();
            statement.setQueryTimeout(30);  // set timeout to 30 sec.
            final String table = " (ID INTEGER PRIMARY KEY AUTOINCREMENT, name text, address text)";

            // create table
            statement.executeUpdate("DROP TABLE IF EXISTS " + DB_TABLE_NAME);
            statement.executeUpdate("CREATE TABLE " + DB_TABLE_NAME + table);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void insert(Person p) {
        try {
            String fmt = "INSERT INTO %s VALUES(%d, '%s', '%s')";
            String q = String.format(fmt, DB_TABLE_NAME, p.getId(), p.getName(), p.getAddress());
            
            statement.execute(q);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public List<Person> findAll() {
        ArrayList<Person> persons = new ArrayList<Person>();
        try {
            rs = statement.executeQuery("SELECT * FROM " + DB_TABLE_NAME);
            while (rs.next()) {
                persons.add(new Person(rs.getInt("id"), rs.getString("name"),
                                       rs.getString("address")));
            }
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return persons;
    }

    public Person findById(int id) {
        Person person = null;
        try {
            String fmt = "SELECT * FROM %s WHERE id = %d";
            String q = String.format(fmt, DB_TABLE_NAME, id);
            rs = statement.executeQuery(q);
            if (rs.next()) {
                person = new Person(rs.getInt("id"), rs.getString("name"),
                                   rs.getString("address"));
            }
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return person;
    }

    public void update(int id, Person p) {
        Person person = findById(id);
        if (person != null) {
            try {
                String fmt = "UPDATE %s SET name = '%s', address = '%s' WHERE id = %d";
                String q = String.format(fmt, DB_TABLE_NAME, p.getName(), p.getAddress(), p.getId());
                
                statement.execute(q);
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public void delete(int id) {
        try {
            String fmt = "DELETE FROM %s WHERE id = %d";
            String q = String.format(fmt, DB_TABLE_NAME, id);
            
            statement.execute(q);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void delete(Person p) {
        delete(p.getId());
    }
}

Person.java

public class Person {
    private static int counter = 1;
    private int id;
    private String name;
    private String address;

    Person(String name, String address) {
        this.name = name;
        this.address = address;
        id = counter;
        counter++;
    }

    Person(int id, String name, String address){
        this.name = name;
        this.address = address;
        this.id = id;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }
    
    public void setId(int id) {
        this.id = id;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "" + id + ", " + name + ", " + address;
    }
}

AddressBookWithDAO.java

public class AddressBookWithDAO {
    public static void main(String[] args) {
        Person p;
        PersonDao personDao = new PersonDaoImpl();

        System.out.println("--- inserting...");
        p = new Person("Seonyoung Kim", "1 Hongji Dong");
        personDao.insert(p);
        p = new Person("Jangkwon Lee", "2 Hongji Dong");
        personDao.insert(p);

        System.out.println("--- finding all...");
        for (Person pi : personDao.findAll()) {
            System.out.println("reading... " + pi);
        }

        System.out.println("--- updating...");
        p = personDao.findAll().get(0);
        p.setName("Sooyoung Lim");
        personDao.update(p.getId(), p);

        System.out.println("--- see if updated...");
        p = personDao.findById(1);
        if (p != null) {
            System.out.println(p);
        }

        System.out.println("--- deleting...");
        personDao.delete(1);  // or personDao.delete(p);

        System.out.println("--- finding all after deleting...");
        for (Person pi : personDao.findAll()) {
            System.out.println("reading... " + pi);
        }
    }
}

[Spring] 스프링 웹 개발 기초

솔라솔 — Fri, 24 Nov 2023 22:08:59 +0900

☀️ 인트로

안녕하세요.솔라솔입니다

김영한 강사님의 첫번째 무료강의, 스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술을 듣고 배운 내용들을 정리해보고자 합니다.

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8

[무료] 스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술 - 인프런 | 강의

스프링 입문자가 예제를 만들어가면서 스프링 웹 애플리케이션 개발 전반을 빠르게 학습할 수 있습니다., 스프링 학습 첫 길잡이! 개발 공부의 길을 잃지 않도록 도와드립니다. 확인해주세

www.inflearn.com

☀️ 정적 컨텐츠

기본적으로 스프링 부트는 정적컨텐츠 기능을 자동으로 제공합니다.

https://docs.spring.io/spring-boot/docs/2.3.1.RELEASE/reference/html/spring-boot-features.html#boot-features-spring-mvc-static-content

Spring Boot Features

Graceful shutdown is supported with all four embedded web servers (Jetty, Reactor Netty, Tomcat, and Undertow) and with both reactive and Servlet-based web applications. It occurs as part of closing the application context and is performed in the earliest

docs.spring.io

docs.spring.io 에 나와있듯이 /static 에서 제공합니다.

 <!DOCTYPE HTML>
  <html>
  <head>
      <title>static content</title>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  </head>
<body>
정적 컨텐츠 입니다.
  </body>
  </html>

위 html 코드의 <body> </body> 부분을 내용을 추가하면,

이런식으로 뜨겠죠?

하지만, 정적 컨텐츠의 단점은 그냥 보이는 그대로 화면에 출력만 된다는 점입니다.

원리는 위와 같습니다. 매우 간단하죠?

☀️ MVC 와 템플릿 엔진

MVC 란? Model, View, Controller

Controller 랑 View 를 쪼개는게 기본이에요

Controller/HelloController

thymeleaf란?

localhost:8080/hello-mvc를 접속해보자

에러가난다

에러메시지를 확인해보자

Required request parameter 'name' for method parameter type String is not present]

라는 에러코드가 떴기때문에

이런식으로 value 와 required를 추가해주어야합니다. 꿀팁 : command+p 누르면 파라미터 정보를 볼 수 있다

?name=spring!

?name=solasol!!!

?name=[ ] -> http에서 Get 방식 입니다.

☀️ API

사실상, 정적컨텐츠를 제외하면 이것을 HTML방식으로 내리느냐, API 방식으로 데이터를 받느냐의 차이임

중요한건 @ResponseBody 를 꼭 넣어줘야함

만약 데이터를 내놓으라 한다면? <- 이래서 API 방식을 많이 쓰는 거

run 해보자

Java bean 방식- getter setter

단축키: command+N

https://cookinghoil.tistory.com/13

Spring - 빈 객체 값 주입 (Setter 메소드)

Bean을 정의할 때 Bean 객체가 가지고 있을 기본 값을 생성자가 아닌 Setter 메서드를 통해 주입할 수 있다. 먼저 다음과 같이 클래스를 생성하여 객체를 만들고 setter,getter을 만들어 준다. public class T

cookinghoil.tistory.com

@ResponseBody란?

스프링에서 비동기 처리를 하는 경우 @RequestBody 와 @ResponseBody 를 사용한다.

클라이언트와 서버의 비동기 통신 처리

여기서 비동기 통신이란 화면전환(새로고침-Refresh, F5) 없이 이루어지는 동작들을 말한다.

굳이 비동기 통신을 이용해야하는 이유는?

예를 들어보자. 우리가 회원가입할때 이름, 아이디, 비밀번호, 전화번호, 주소 등을 모두 입력하고 아이디 중복 버튼을 누를때 서버에서 응답후 Refresh 되어 입력한 값들이 모두 사라진다면 곤란 할 것이다. -> 이럴때 비동기통신처리를 하는 것이다.

웹에서 이루어진는 데이터 통신은 클라이언트와 서버간에서 이루어지는 것이다.

중요한건 요청(Request) 와 응답(Response)

클라이언트에서 서버로 통신하는 메시지를 요청메시지

서버에서 클라이언트로 통신하는 메시지를 응답메시지

RequestBody 와 ResponseBody

비동기 통신을 하기 위해서는 요청메시지와 응답메시지를 본문(Body) 에 담아보낼때 필요하다.

JSON (Javascript Object Notation)

본문에 담아야하는 데이터 형식의 가장 대표적인 방식이다.

ResponseBody 사용 원리

☀️ 참고자료

김영한 개발자님 강의 자료

[CJ UNIT 6th] 유튜브 데뷔 후기 + 상장 모음집

솔라솔 — Fri, 24 Nov 2023 05:56:42 +0900

안녕하세요. 솔라솔입니다

오늘은 예전에 찍었던 CJ UNIT 6th 로서 촬영했던 7기 모집영상 후기 와 상장모음집을 가져왔습니다.

https://blog.naver.com/dodosolsol_/222829382707

[CJ UNIT 6기] 7기 모집 유튜브 데뷔

모두모두집중!! 7기 모집이 시작되었습니다!!! 정말 다양한 경험을 할 수 있어요!!! 강사일만 하지 않아요!...

blog.naver.com

뿌듯한 4관왕

과거 노션에 작성했던 포트폴리오 중 일부

언젠가 기회가 된다면 최종 활동 후기를 한번 더 적어내려보고 싶을 정도로

자랑스럽기만 했던 CJ UNIT 활동이었습니다.

교육봉사에 관심이 있고, 아이들을 좋아하며, 컴퓨터과학관련 전공자라면 더할 나위 없는 최고의 대외활동이 되리라 자부합니다.

신기하게도, CJ UNIT 에서 만난 인연들이 훗날 저에게 좋은 영향을 많이 미치게 되더라구요 (IT 판이 좁아서 그런거려나요)

이렇게 열심히 살던 친구들이, 여전히 열심히 사회에서 이곳저곳에서 살고 있구나 를 깨달으며 오늘도 본받는 유닛 친구들이 있어서 감사할 따름입니다.

참고로 CJ UNIT 이 된다면, CJ 올리브네트웍스 소속이기 때문에 공식홈페이지에도 얼굴이 올라가게된답니다!

이렇게 말이죠!

https://www.cjolivenetworks.co.kr/sustainability/contribution/education_volunteers/member

CJ올리브네트웍스의 CJ SW창의캠프 대학생 봉사단을 소개합니다.

www.cjolivenetworks.co.kr

유닛 활동 관련 질문은 언제나 환영입니다!

자유롭게 댓글 남겨 주세요!

[CJ UNIT 6th] 제주여중 현장지원 후기

솔라솔 — Fri, 24 Nov 2023 03:47:21 +0900

안녕하세요. 솔라솔입니다.

이 그림의 출처는 제 짝궁이었던 조장님입니다.

오늘은 지난 포스팅에 이어서 CJ UNIT 6th 활동 당시 제주여자중학교에 현장지원 다녀왔던 이야기를 들고 왔습니다.

해당 포스팅 참고해주세요!

https://blog.naver.com/dodosolsol_/222816909748

[CJ UNIT 6기] 제주여중 현장지원 후기. 더위먹은 썰을 곁들인..

근데 이때가 시작이었음 얼레벌레의 시작 탑승시각 7:10아침 우리 조 모여서 들어가기로 한 시각 6:40 여의...

blog.naver.com

[CJ UNIT 6th] 활동후기

솔라솔 — Fri, 24 Nov 2023 02:44:33 +0900

안녕하세요. 솔라솔입니다.

이 그림의 출처는 제 짝궁이었던 조장님입니다.

오늘은 예전에 썼던 활동 후기들을 들고 왔습니다.

이 포스팅들은 다 사진 위주라서 링크로 들고왔습니다. 참고해주세요!

https://blog.naver.com/dodosolsol_/222816834144

[CJ UNIT 6기] 활동 요약1..아니고 노는게 제일좋아! 뽀로로일기

정말..정말정말 내가 대학생활동안 버킷리스트 1위었을 정도로 하고싶었던 CJ UNIT 6기 활동요약. 1(...

blog.naver.com

https://blog.naver.com/dodosolsol_/222816866548

[CJ UNIT 6기] 활동 요약2 아니고 뽀로로 일기

노는게 제일좋아~ 활동요약 후기2 는 오디티 모드에서 찍은 사진 모음zip으로 시작 여기 올리는 사진들은 ...

blog.naver.com