조건부 연산자로, 자바에서 ?와 :를 사용하여 작성 간단한 조건문을 한 줄로 표현할 수 있어 코드가 더 간결해짐

result = (condition) ? valueIfTrue : valueIfFalse;

• condition : 평가될 조건식. 조건식의 결과는 true 또는 false
• valueIfTrue: 조건이 true일 때 반환될 값
• valueIfFalse: 조건이 false일 때 반환될 값

예제

int a = 5;
int b = 10;
int max = (a > b) ? a : b;

max = 10

2차원 배열

2차원 배열은 배열의 배열로 구성되며, 행과 열의 형태로 데이터를 저장

• 2차원 배열 선언

  int[][] arr;

• 2차원 배열 초기화

  1. 정적 초기화 (크기 지정 후 값 설정)

     int[][] arr = new int[3][4]; // 3행 4열의 2차원 배열 선언

  2. 동적 초기화 (값을 직접 지정)

     int[][] arr = {
     {1, 2, 3, 4},
     {5, 6, 7, 8},
     {9, 10, 11, 12}
     };

ex. arr[1][2]는 두 번째 행의 세 번째 요소

배열 랜덤으로 가져오기

import java.util.Random;

Random ran = new Random();
dice[ran.nextInt(6)]

• 길찾기, 크롤링 스케줄러 등 지나가는 말로 이야기한 기능도 다 구현을 했다.
• 이메일을 실제 상업메일처럼 잘 구성해서 보낸 것도 인상적이었다.
• 관심설정 추천이메일은 서비스화한다면 대용량으로 처리해야하는 이슈가 발생할것. 여러 기술들을 공부해서 이부분 완성하면 좋을 것 같다.

외부 심사위원님 피드백

• 팝업스토어 정보를 모아서 보여준것 외에도 좋아요, 후기, 대기, 예약 등 사용자 활동기능이 있는게 좋았다.
• 기능의 갯수나 유즈케이스를 잘 정리해서 구현했다.
• 초반 DB설계가 잘 되어서 후에 좋은 영향을 준 것 같다.
• 이벤트 별로 달라질수있는 데이터나 정책이 있을 수 있는데, (팝업의 주최자마다 요구사항이 다른 점) 이부분을 모두 관리자가 처리하긴 어려울 것이니 이부분 보완 필요
• 개선사항으로 언급하긴했지만 줄을 다시 서는 기능이 있으면 좋을것같다
• 삭제한게 크롤링되면서 다시추가되는 현상이 있는데, 좋은 흐름은 아니다. 크롤링에서 제외하는 기능이라든지 있으면 좋을 것 같다.
• 길찾기는 사이트 내에서 하지않고 어플리케이션으로 이동해도 괜찮을 것 같다. 이미 잘 되어있고, 횟수가 넘어가면 요금이 부과된다.

동료 수강생 피드백

• 이벤트 등록을 관리자계정에서만 해야하나? 라이트하게 열 수 있으니 이쪽으로도 접근해보면 좋을 것 같다.
• 사용자의 후기만 보여줄수있는 게시판이 있으면 좋을 것 같다.

결과

최우수팀 상을 받았습니다!! 회의하고 수정하고 회의하고 수정하고 *1000 했던 많은 시간들이 떠오르며 정말 감사하고 행복했습니다. 좋은 팀원들을 만나 여기까지 올 수 있었던 것 같아요. 더 개발하고싶었던 것들이 있었지만, 완성도를 위해 아쉽게 하지 못했던 것들도, 피드백받은 것들도 더 손보고싶습니다. 발표연습도 정말 여러 번 했는데 실수없이 잘 진행된 것 같아서 만족스러워요!

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

시연 DB 체크 및 정리본 만들기(노션, 발표스크립트 참고) => 체크리스트 만들고 발표때 진행 ✔️

포트폴리오 취합 및 정리 ✔️

일요일 19시 제출자료 정리 및 제출(WBS, 소스코드, /최종기획안, 포트폴리오, 발표ppt) - 구글드라이브 ✔️

MLP 개인제출자료 제출 ✔️

20시 발표시연 및 피드백 ✔️

발표전 사전확인

• 시연에 필요한 데이터 미리 작성해놓고 복붙하며 시연

• 불필요한 예약 기록지우기

• 후기 여러개 등록해두기(삭제시연연습위해)

• DB조작을 위해 디비버 켜두기

• 헬로키티 좋아요 제거 해놓기 (시연 시작 시점)

• 대기 데이터 작업

use hereevent;

insert into wait (event_no,wait_tel,email,wait_date,state) values 
(199,'010-1111-1111','wefjnkf@example.com',NOW(),'wait'),
(199,'010-1111-3333','fwef433@example.com',NOW(),'wait'),
(199,'010-1111-4444','dfess2@example.com',NOW(),'wait'),
(199,'010-1111-5555','asdf1234@example.com',NOW(),'wait'),
(199,'010-1111-6666','r1d2s2@example.com',NOW(),'wait'),
(199,'010-1111-2222','ggoing@example.com',NOW(),'wait'),
(199,'010-1111-7777','seego21@example.com',NOW(),'wait'),
(199,'010-1111-8888','sfe889@example.com',NOW(),'wait'),
(199,'010-1111-9999','goodisalan@example.com',NOW(),'wait'),
(199,'010-1111-1010','weiofg@example.com',NOW(),'wait');

insert into wait (event_no,wait_tel,email,wait_date,state) values 
(179,'010-1111-1232','1wngog@example.com',NOW(),'wait'),
(179,'010-1111-3546','dfsdf55@example.com',NOW(),'wait'),
(179,'010-1111-1422','erg154@example.com',NOW(),'wait'),
(179,'010-4686-4965','454fjisd@gmail.com',NOW(),'wait');

• 마이페이지에서 보여주며 순서 5번째일때 179번 대기 1번 cancel처리(90초가량 소요)

• !!!!앞에 3명 남은 메일 오는거 보여줄때 모두 cancel처리

• (관리페이지 이벤트 선택삭제) 이후 바로 관리자로그인-크롤링

소감

• 발표에 대한 모든 준비를 마치고, 시연하며 발표준비의 완벽도를 높이는 연습을 하고있다.
• 필요한 제출자료를 모두 제출하고 발표만을 앞두니 정말 시원섭섭한 느낌이 든다.
• 발표를 하면서 발표자를 뒷받침해주기 위해 화면을 조작해주는 일, 여러 경우의 수를 보여주기 위해 타이밍에 맞추어 DB를 조작하는 일 등을 준비하는게 왠지 재미있다.
• 몇 달 동안 우리를 이끌어주신 강사님과 함께 작업하고 공부한 동료수강생들과 이별하는게 아직 실감이 안난다 ㅜㅜ 언젠가 다시 마주할 날이 오길..~~

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

• 발표 시연 피드백 ✔️

• 멘토님 피드백 정리 ✔️

• 영상편집 마무리 ✔️

• 영상편집 피드백 후 통합 ✔️

• 시연영상 구글드라이브 제출 ✔️

• 유튜브 채널 개설 및 영상 업로드 ✔️ HereEvent 시연영상

• 시연 DB 체크 및 정리본 만들기(노션, 발표스크립트 참고)

• 포트폴리오 취합 및 정리 => 체크리스트 만들고 발표때 진행

• 일요일 19시 제출자료 정리 및 제출(WBS, 소스코드, /최종기획안, 포트폴리오, 발표ppt) - 구글드라이브

• MLP 개인제출자료 제출

• 20시 발표시연 및 피드백

발표시 참고할 피드백

• ppt발표와 시연시간 비중 2:1~ 3:1(시연은 최대 10분 내외)

• 입력데이터 있는 경우 미리 써놓기

• 시연데이터 미리 db에 준비해두기

• 마이크와 발표톤 듣기 편하게 진행

• 주요기능 위주로 발표, 수정/삭제/목록보기 등 중복사항은 생략

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

• 발표 구성 및 순서 정하기
• 수행일지 작성 및 업로드
• 강사님 피드백 & 피드백 내용 정리(노션 및 수행일지에 작성)
• 시연영상편집
• 시연영상 편집본 피드백
• 추가녹화 내용 : 이벤트 추천 이메일, 관리 메인페이지, 관리 목록 2개 추가내역, 크롤링, 예약당일 입장/취소버튼 뜨는 부분
• 크롤링된 DB 이벤트테이블 작업
• 회원 이미지 저장경로 오류 수정
• jar파일 서버 업데이트

오늘의 생각

• 중간중간 적재적소에 역할을 분담하여 막힘없이 잘 흘러가는 듯 하다.

• 어제 뽑기로 정한 프로젝트 발표 순서와 발표당일 시간표가 오늘 업로드되었다. 시간표만 봐도 너무 떨린다... 주말엔 멘토님께 피드백받고 시연연습을 반복하는 일만 남았다..!!!

• 강의 듣는 동안 하루도 온전히 쉰 날이 없을 만큼 달려오기도 했고, 주말없이 진행한 한달 반 가량의 프로젝트도 준비한대로 마무리가 되어가니 너무 뿌듯하고 기분이 좋다! 중간중간 정리하고 회의하고 하는 과정이 피로하게 느껴질 때도 있었지만, 그 작업을 계속 해준 덕에 계획에서 크게 어긋나지 않고 마무리되어간다고 생각한다.

• 욕심나는 부분도 있었지만, 전반적인 완성도를 위하여 가져갈부분을 초반부터 확실히 정하고 우선순위대로 작업하는게 단기 프로젝트에서는 무엇보다 중요한 것 같다. 멘토님과 강사님의 피드백 덕이다!!

• 프로젝트동안 가끔 시간을 써서 열심히 작업한 부분을 버리고 새로 작업해야하는 순간들이 있었다. 나 말고도 다른 분들도 마찬가지였다. 그럴때 당연히 아쉬운 마음이 들지만, 강의를 듣기 전 많이 들은 고인물 개발자들의 조언이 떠오른다. 진짜 잘하는 개발자는 자기가 쓴 코드에 집착하지 않는다는 말.. 그 생각을 하며 아쉬움은 빠르게 털어내고 목표에 도달하는 데에 가까운 방식을 채택하는 방법을 체득할 수 있었던 것 같다.

• 우리 팀이 만든 프로젝트에 애착이 생기는 만큼, 다른 조들도 자식같은(?ㅋㅋ) 프로젝트를 만들어냈을텐데 너무 궁금하고 기대된다!!

• 발표날까지 아자아자 팟팅이다~!!!!

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

다른 데이터는 그냥 삽입해두면 되는데 시간에 따라 데이터가 변경되는 예약과 대기기능은 데이터를 어떻게 해야할지 고민이 조금 길어졌었다. 결국 특정 이벤트를 정하여 시연 이전에 추가하는 방식을 사용하기로 했다. 예약은 시연날짜를 기준으로 다시 정리하여 올려야 한다.

서버에 배포하는 과정에서는 큰 어려움이 없을줄로만 알았는데, 계획보다 이르게 주말에 서버를 생성하고 배포해보길 잘했다. http환경에서 되지 않는 작업들이 은근 있었던것.. 내위치를 가져오는 기능도 https환경에서만 가능하고 길찾기 기능도 문제가 생겨서 담당하신 분이 2-3일 고생했었다. 그외에도 지도, 소셜로그인 등의 ip주소를 변경하는 등 생각보다 여러 작업들이 필요했다.

미리 준비해도 빠듯하게 느껴지는 시간들..! 그 와중에 시간 앞당겨서 한게 얼마나 다행으로 여겨지던지..

어제오늘까지 작업한 기능들 정리하고 오늘부터는 거의 다 준비된 데이터와 기능들을 바탕으로 화면녹화를 뜨고 내일부터는 시연영상 편집을 하려고 한다.

중간중간 회의하고 의견 나눌 것이 계속 생긴다. 또 잘하고싶은 욕심과 가끔 느껴지는 벽들에 조금은 지치기도 했던 요며칠이었지만..! 그래도 작업했던 것들 정리하고 또 하나하나씩 개선되어가는 것들을 보며 다시 힘을 얻는다.

꾸준히 올려오던 벨로그를 드문드문 올리게 되어 조금은 아쉽지만 ㅜ 그래도 남은 시간 틈틈이 더 기록해볼수있길..!

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

1. intelliJ에서 jar파일 생성 Gradle - task - build - bootJar

물리적경로 확인

2. cmd창에서 위치이동

   C:\Users\주희>cd C:\backend23\work\team_pro\build\libs

C:\backend23\work\team_pro\build\libs>scp ./hereevent-0.0.1-SNAPSHOT.jar root@223.130.158.5:/root/upload
root@223.130.158.5's password:
hereevent-0.0.1-SNAPSHOT.jar   

로그인 root로 하고 하면 서버스타트됨

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation group: 'org.modelmapper', name: 'modelmapper', version: '2.4.0'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    runtimeOnly 'com.oracle.database.jdbc:ojdbc11'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

application.properties

spring.application.name=erp
server.port=8088


#db ??? ?? ??
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@127.0.0.1:1521:xe
spring.datasource.username=test
spring.datasource.password=test

#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#spring.datasource.url=jdbc:mysql://db-nt04n-kr.vpc-pub-cdb.ntruss.com:3306/myerp?serverTimezone=UTC
#spring.datasource.username=myerp
#spring.datasource.password=myerp2024!

#mybatis ??? ?? ??
mybatis.mapper-locations=classpath:/mapper/*.xml
mybatis.type-aliases-package=com.example.erp.dto

#redis
spring.data.redis.host=127.0.0.1
spring.data.redis.port=6379
#spring.data.redis.password=

#jpa????
#???? ??? ???? ?????. drop ??? ???? create
#spring.jpa.hibernate.ddl-auto=create
spring.jpa.hibernate.ddl-auto=none
spring.sql.init.encoding=UTF-8
spring.sql.init.mode=always


#sysout?? ??
spring.jpa.show-sql=true

#JPA log
#??????? ???? ???? sql??
logging.level.org.hibernate.sql=debug
logging.level.org.hibernate.type.descriptor.sql=trace

#JPA? ???? sql? ??? ????
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true

jpa.defer-datasource-initialization=true

config

RedisConfig

@Configuration
public class RedisConfig {
    @Value("${spring.data.redis.host}")
    private String host;
    @Value("${spring.data.redis.port}")
    private int port;
    /*@Value("{spring.data.redis.password}")
    private String password;*/

    //LettuceConnectionFactory는 Redis서버와 연결을 설정하고 관리하는 객체
    //이를 통해서 spring data redis내부에서 redis서버와 통신할 ㅅ 있다.
    @Bean
    public RedisConnectionFactory redisConnectionFactory(){
        //config객체를 만들고
        RedisStandaloneConfiguration config =
                new RedisStandaloneConfiguration(host,port);
        //config.setPassword(password);

        //config를 이용해서 factory객체를 만들어서 리턴
        return new LettuceConnectionFactory(config);
    }

    @Bean
    @Primary //빈을 만들때 우선순위 높게 지정
    public RedisTemplate<String,String> redisTemplate(){
        RedisTemplate<String,String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        //hashes operation을 사용하는 경우
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());

        return redisTemplate;
    }
}

hashes

Subject

• @RedisHash : redis에 저장할 클래스를 생성
• value는 redis에 들어갈 객체의 key가 된디
• 키는 value에 지정한 key:entityid =>mysubject : id

  @Data
  @NoArgsConstructor
  @AllArgsConstructor
  @RedisHash(value = "mysubject")
  public class Subject {
    @Id
    private String id;
    private String name;
    private int price;
    private String info;
  }
  

### SubjectHashController
```java
@RestController
@RequiredArgsConstructor
public class SubjectHashController {
    private final SubjectHashService service;
    //request용 response용 dto는 따로 만들어서 작업하기
    //redis에 저장하기
    @PostMapping("/hashtest")
    public Subject save(@RequestBody Subject subject){
        System.out.println(subject);
        return service.save(subject);
    }

    //redis에 저장된 데이터 불러오기
    @GetMapping("/hashtest")
    public Subject find(@RequestParam("id") String id){
        return service.findById(id);
    }
}

SubjectHashRepository

public interface SubjectHashRepository extends CrudRepository<Subject,String> {
}

SubjectHashService

public interface SubjectHashService {
    Subject save(Subject subject);
    Subject findById(String id);

}

SubjectHashServiceImpl

@Service
@RequiredArgsConstructor
public class SubjectHashServiceImpl implements SubjectHashService{
    private final SubjectHashRepository repository;

    @Override
    public Subject save(Subject subject) {
        return repository.save(subject);
    }

    @Override
    public Subject findById(String id) {
        return repository.findById(id).get();
    }
}

sortedset

Product

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Product {
    private String categoryId;//key
    private String productId;//member(sortedset에 저장되는 각 요소)
    private int price;//score
}

SortedSetController

@RestController
@RequiredArgsConstructor
public class SortedSetController {
    private final SortedSetService service;

    @GetMapping("/getzset")
    public Set<ZSetOperations.TypedTuple<String>> getzsetvalues(@RequestParam("key") String key){
        return service.getZsetValues(key);
    }

    @PostMapping("/add")
    public int create(@RequestBody Product newProduct){
        service.createMember(newProduct);
        return service.getRank(newProduct);
    }
}

SortedSetService

public interface SortedSetService {
    //전체 sorted set의 멤버들 조회
    //ZSetOperations은 sortedset을 다루기 위해 여러가지 메소드를 제공하는 인터페이스
    //TypedTuple은 spring data redis에서 제공하는 인터페이스 - sortedset의 자료구조를 모델링한 객체
    Set<ZSetOperations.TypedTuple<String>> getZsetValues(String key);
    //새로운 member를 저장
    void createMember(Product newProduct);
    //매개변수로 정의한 상품의 rank구하기
    int getRank(Product newProduct);
}

SortedSetServiceImpl

@Service
@RequiredArgsConstructor
public class SortedSetServiceImpl implements SortedSetService{
    private final RedisTemplate<String,String> redisTemplate;

    //sortedset에 저장된 모든 member와 score를 조회
    @Override
    public Set<ZSetOperations.TypedTuple<String>> getZsetValues(String key) {
        ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<String>> sortedset = zSetOperations.rangeWithScores(key,0,-1);
        return sortedset;
    }

    @Override
    public void createMember(Product newProduct) {
        ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
        //key,member,score
        zSetOperations.add(newProduct.getCategoryId(),
                newProduct.getProductId(), newProduct.getPrice());
    }

    //정의한 객체의 순위를 리턴
    @Override
    public int getRank(Product newProduct) {
        ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
        int rank = zSetOperations.rank(newProduct.getCategoryId(),
                newProduct.getProductId()).intValue();
        return rank;
    }
}

C:\Users\주희>cd\

C:\>cd C:\Program Files\Redis

C:\Program Files\Redis>redis-cli

127.0.0.1:6379> keys *
1) "cate001"
2) "mysubject"
3) "mysubject:subject02"
4) "test1"
5) "mysubject:subject01"

127.0.0.1:6379> zrange cate001 0 -1
1) "prd02"

127.0.0.1:6379> zrange cate001 0 -1
1) "prd01"
2) "prd03"
3) "prd02"

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

⇒ 이번 주 안으로 끝내기(1차 마감 금요일, 2차 마감 일요일)

• 관리자페이지(후기 form참고)

  • 이벤트관리
  • 회원관리
  • 후기관리(선택 삭제만 남음)
  • 관리자 메인 페이지 차트 (날짜별 등록 회원 수, 날짜별 오픈 이벤트, …)

• 이메일 보내기 (예약, 대기 관련)

• 상세페이지

  • 달력 마무리

  • 길찾기

    ODsay LAB

• 지도 (마커-목록 싱크맞추기)

• 기타 기능

  • 해시태그 크롤링
  • 문자 보내기

• 프론트엔드 보완

  • 메인배너
  • 기타 프론트 보완 및 추가 필요
  • 상세페이지
  • 대기페이지
  • 카테고리별 목록(4개씩 출력)

• 파일정리

  • 컨트롤러 분리
  • css, js파일 분리

마지막 주 타임 라인

• 포트폴리오 자료정리
  • 기한 : ~ 수요일까지
  • 양식 있는지 확인/ 매니저님께 요청
  • 참고방향 : 사이트의 차별성과 필요성 설득력있게 기술, 다함께 중간점검으로 수정/보완작업하기

• 시연동영상 녹화, 편집

  • 기한 : ~금요일
  • 멘토님 피드백 후 한번 더 보완

• 포트폴리오 디자인

  • 기한 : ~금요일

• 서버 등록

  • 기한 : ~수요일

• 기획안 수정

  • 기한 : ~수요일

• db 자료 등록 : 회원(등록날짜 6-7월 사이 다양하게), 리뷰, 예약/대기, …

  • 기한 : ~수요일

• 발표

  • 기한 : 토~일
  • 준비방향 : 대본 각자 준비(~토요일), 최소 3회 이상 시연 및 피드백 진행, 일요일 최종 시연 후 마무리, 가능하면 멘토님 앞에서 1회라도 시연하기
  • 파트 : 마이페이지, 관리자페이지, 상세페이지, 메인페이지, 지도페이지

기록

• 발표가 2주 앞으로 다가와서 남은 시간을 어떻게 보낼지 회의를 함.
• 기능들이 거의 마무리되어가기에 초반에 나눈 기능별 역할분담을 다시 업데이트할 필요가 있다고 느낌.
• 자신이 원하는 파트, 남은 시간 필요한 파트 등을 반영하여 다시 역할분담함.
• 멘토님도 강사님도 중요하다고 생각하시는 기능에 차이가 조금은 있어, 여러 관점을 반영하여 남은 시간을 세팅하도록 함.
• 발표준비와 개발의 완성도있는 마무리를 위해 의미있는 시간이었다고 느낌!
• 역할분담을 하며 느낀거지만, 우리 팀원들은 다 배울 점이 있는 것 같아 감사함을 느낌!

+ 출석률

출석은 당연한거지만.. 총 일수가 되어갈수록 빽빽한 진행률이 날 기분 좋게 만든다!

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

redis.io

1. String

단일값저장

set key get key

2. SortedSet

ZSet이라고도 한다. 저장된 데이터를 유니크하게 관리하기 위해서 사용

1) zadd

zadd key score member

• key : sortedset의 이름
• score : 각 요소에 할당된 점수
• member : 각 요소의 이름(값)

2) zrange

정렬된 원소에서 내가 출력하고 싶은 start번호 end번호 첫번째요소가 0 마지막요소가 -1

3) zrem

삭제

4) zrangebyscore

zrangebyscore key min max

zrangebyscore key (min(max

=> min초과 max미만

5) zrevrangebyscore

zrevrangebyscore myset1 +inf (20000 withscores

20000보다 높은 score의 member들을 조회

6) zscore

zscore key member

지정한 member에 대한 score를 조회

7) zrank

zrank key member

해당 member의 순위 조회

실습

key => myboard

1. 게시글과 조회수를 sortedset에 저장

5개를 임의로 저장 조회수와 게시글번호

2. 전체글과 조회수를 모두 조회

3. 조회수가 가장 많은 글 조회

4. 1위의 게시글 조회

hash

실습

BoardDTO의 모든 값을 hashes로 저장하기 myboardhash

redis intelliJ프로젝트 만들기

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

토요일에 받은 멘토링을 바탕으로 우선순위를 재분류하고 남은 일들을 효율적으로 재구성하며 마무리를 하고있다.

오늘 했던 작업은 크게 메인페이지(index)에 피드백을 바탕으로 추가적인 효과를 주는 작업과 이벤트 목록 페이지를 보수하는 작업 두개로 분류할 수 있다.

메인페이지 작업

• autoplay 효과가 없애기
• loop 없애기
• 순위가 있는 목록에 순위 표시하기
• 목록별로 제목 누르면 이벤트 카드목록으로 볼 수 있게 연결하기
• 카테고리만 목록의 양식이 달랐는데 통일하기
• hover시에 이벤트 정보(이벤트 이름, 별점, 기간 등) 보이게 하기
• 넘치는 글자는 한 줄로 자르고 생략문자 주기

메인페이지 작업 중 생긴 문제

• hover 효과를 주니 태그 안에 주었던 onclick이 작동하지 않음 => pointer-events: auto; 와 z-index: 2;를 주어도 해결되지 않음 (아마 js코드가 아닌 태그 안에 준 onclick이라 그런듯) => hover하는 태그에 이미지 태그에 있던 onclick을 주니 다시 작동함
• 순위를 어떻게 줄지 고민 each에 i를 부여하고 0부터 나오는 index에 1을 추가하고 문자인 "위"를 옆에 추가함
• 목록이 뜨지 않아서 mapper에 있는 sql문을 수정
  #### 목록페이지 작업
• 피드백대로 기간을 추가하고 정렬과 텍스트 배치 수정
• 검색 목록화면과 카테고리 목록화면도 함께 수정
• 상단바 추가하기
• 지도 마커 닫기표시랑 제목이 겹치지 않게 수정

참고했던 글

이미지 hover시 글자표시

글자수 초과시 생략문자주기

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

다대다 채팅 그룹채팅 관련하여 수업진행함

중간점검 및 논의

• 팀프로젝트 기능개발은 막바지로 향해서 마무리작업과 보충이 필요한 부분을 각자 공유함 : 프론트를 사용자측면에서 작업하기 위한 고민을 멘토링때 나누기로함
• 내일 주간일지 제출을 위해 한주 각자 작업했던 내용과 다음주 계획을 공유하고 역할재분배를 함
• 어려움이 있는 부분을 공유하고, 서로가 도와줄 수 있는 지점을 체크함
• 내일 멘토링 이전 점검을 위한 피드백 시간을 강사님께 요청함

팀프로젝트 진행하며 배운 기능 일부

• dto 파라미터를 ajax로 넘기는 방법을 배웠음.. 이부분 팀프로젝트 기간 중 제일 오랜시간 할애함
• 부트스트랩 샘플을 수정하는 과정에서 css가 잘 적용되지 않는 부분이 있었음. jquery로 생성하는 부분이라 잘 되지 않았는지.. 이부분 body에 삽입하는 div태그에 id를 주어 해결함
• db데이터를 jquery로 넘기는 게 익숙하지 않았지만 하다보니 적응할 수 있었음

팀프로젝트 및 과정 종료를 3주정도 앞두고..

• 주변의 도움을 받기도 하고, 가끔은 주기도 하는 과정이 재밌고 보람참
• 역시 직접 해보고 고민하고 해결하는게 제일 재밌음
• 도움을 청할 수 있는 팀원, 강사님, 멘토님이 있는 게 감사한 나날..~
• 과정 시작부터 중간과정 중 팀 내에서도 피드백과 계획재수립이 계속 오가기도 하지만, 주간일지, 멘토링, 피드백시간 등이 주기적으로 있어서 늘어지지않고 템포를 유지할 수 있는 것 같다
• 만족할만한 마무리를 위해서.. 남은 시간도 아자아자 팟팅이다~!

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

서버에 등록/배포하여 동시접속 시연해보기

웹소켓 사진전송

WebSocketController

@Controller
public class WebSocketController {
    @GetMapping("/chat")
    public String showview(){
        return "chat";
    }
    @GetMapping("/chat2")
    public String showView2() {
        System.out.println("컨트롤러");
        return "chatt2";
    }
}

MyBinaryHandler

@Component
public class MyBinaryHandler extends TextWebSocketHandler{
    HashMap<String, WebSocketSession> sessionMap = new HashMap<>(); //웹소켓 세션을 담아둘 맵
    private static final String FILE_UPLOAD_PATH = "C:\\chat";
    static int fileUploadIdx = 0;
    static String fileUploadSession = "";

    //소켓연결
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // TODO Auto-generated method stub
        super.afterConnectionEstablished(session);
        System.out.println("연결");
        sessionMap.put(session.getId(), session);
    }
    //메시지전송
    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws JsonMappingException, JsonProcessingException{
        try {
            String msg = message.getPayload();
            //fileUploadSession = msg;
            ObjectMapper objectMapper = new ObjectMapper();
            //ChattDTO dto =  objectMapper.readValue(msg, new TypeReference<Map<String, Object>>(){});
            Map<String, Object> chatMap =  objectMapper.readValue(msg, new TypeReference<Map<String, Object>>(){});
            String type=(String)chatMap.get("type");
            System.out.println("type:"+type);
            if(!type.equals("fileUpload")) {
                for(String key : sessionMap.keySet()) {
                    WebSocketSession wss = sessionMap.get(key);
                    System.out.println(msg);

                    wss.sendMessage(new TextMessage(msg));

                }
            }else {
                fileUploadSession = msg;
                System.out.println("파일업로드가 발생됨"+fileUploadSession);
//                for(String key : sessionMap.keySet()) {
//                    WebSocketSession wss = sessionMap.get(key);
//                    System.out.println(msg);
//                    
//                    wss.sendMessage(new TextMessage(msg));
//                    
//                }
            }
        }catch(Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) {
        // TODO Auto-generated method stub
        //super.handleBinaryMessage(session, message);
        System.out.println("바이너리데이터 전송됨");
        System.out.println(message);

        ByteBuffer byteBuffer = message.getPayload();
        String fileName = "temp.jpg";
        File dir = new File(FILE_UPLOAD_PATH);
        if(!dir.exists()) {
            dir.mkdirs();
        }

        File file = new File(FILE_UPLOAD_PATH, fileName);
        FileOutputStream out = null;
        FileChannel outChannel = null;
        try {
            byteBuffer.flip(); //byteBuffer를 읽기 위해 세팅
            out = new FileOutputStream(file, true); //생성을 위해 OutputStream을 연다.
            outChannel = out.getChannel(); //채널을 열고
            byteBuffer.compact(); //파일을 복사한다.
            outChannel.write(byteBuffer); //파일을 쓴다.
        }catch(Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(out != null) {
                    out.close();
                }
                if(outChannel != null) {
                    outChannel.close();
                }
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
        byteBuffer.position(0); //파일을 저장하면서 position값이 변경되었으므로 0으로 초기화한다.
        //파일쓰기가 끝나면 이미지를 발송한다.
        //HashMap<String, Object> temp = sessionMap.get(fileUploadIdx);
        for(String k : sessionMap.keySet()) {
//            
//            WebSocketSession wss = (WebSocketSession) temp.get(k);
            try {
                WebSocketSession wss = sessionMap.get(k);
                //System.out.println(msg);
                System.out.println(fileUploadSession+"_______");
                wss.sendMessage(new TextMessage(fileUploadSession));

                wss.sendMessage(new BinaryMessage(byteBuffer)); //초기화된 버퍼를 발송한다.
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //소켓종료
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        // TODO Auto-generated method stub
        System.out.println("종료");
        sessionMap.remove(session.getId());
        super.afterConnectionClosed(session, status);
    }

}

WebSocketConfigVer2

@Configuration
@EnableWebSocket
public class WebSocketConfigVer2 implements WebSocketConfigurer{

    //웹소켓 핸들러 객체에 매핑하기
    // /mywebsocket으로 요청하면 웹소켓핸들러가 동작할 수 있도록 등록하기
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHendler(),"/chatting");
        //.setAllowedOrigins("*");
        System.out.println("등록완료");
    }
    //핸들러 객체 리턴하기
    @Bean
    public WebSocketHandler myHendler() {
        return new MyBinaryHandler();
    }

    @Bean
    public ServletServerContainerFactoryBean createWebSocketContainer() {
        ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
        container.setMaxTextMessageBufferSize(8192);
        container.setMaxBinaryMessageBufferSize(50000000);
        return container;
    }

}

chatt2.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<script
    src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.0/jquery.min.js"></script>
    <style type="text/css">
        #talklist{
            border:1px solid;
            width: 600px;
            height: 400px;
            overflow: auto;
        }
        #msg{
            border:1px solid;
            width: 550px;
            margin-top: 10px
        }
        #sendbtn{
            height: 40px;
            margin-top: 10px;
        }
        #id{
            width: 350px;
            margin-bottom: 10px
        }
        .me{
            background: #F5F0C5;
            width: 70%;
            float: right;
            margin: 1px;
        }
        .other{
            background: #dcdcdc;
            width: 70%;
            float: left;
            margin: 1px
        }
    </style>

</head>
<body>
    <div id='chatt'>
        <h1>웹 소켓 채팅~~</h1>
        <input type='text' id='id' >
        <input type='button' value='채팅참여' id='joinbtn' >
        <input type='button' value='채팅종료' id='btnclose' >
        <br/>
        <div id='talklist'></div>
        <div id='sendZone'>
            <textarea id='msg' ></textarea>
            <input type="file" id="myimg">
            <input type='button' value='전송' id='sendbtn'>
            <input type='button' value='파일올리기' id='filesend' onclick="fileSend()">
        </div>
    </div>
    <script type="text/javascript">

        let mydata = {};//전송 데이터(JSON)
        $(document).ready(function(){
            $("#joinbtn").on("click", function(){
            //    ws = new WebSocket("ws://10.10.0.17/chatting");
            ws = new WebSocket("ws://" + location.host + "/chatting");
                //웹 소켓에서 메시지가 날라왔을 때 호출되는 이벤트
                let resid="";
                ws.onmessage = function(msg){
                    var data = msg.data;

                    if(data != null && data.type != ''){
                        let resMsg = JSON.parse(data);
                        console.log("&&&&&&&&&&&"+resMsg)
                        resid = resMsg.id
                        let msgcss = "";
                        console.log("$$$$$$$$$$"+resid)
                        if(resMsg.id == $("#id").val()){
                            msgcss = 'class=me';
                        }else{
                            msgcss = 'class=other';
                        }
                        //alert(msg.data)
                        let item = "<div "+msgcss+"><span><b>"+resMsg.id+"</b></span> [ "+resMsg.date+" ]<br/>"+
                                    "<span>"+resMsg.msg+"</span></div>";
                        $("#talklist").append(item)

                        console.log("====="+resid);
                    }else{
                        console.log("--------"+resid);
                        if(resid == $("#id").val()){
                            msgcss = 'class=me';
                        }else{
                            msgcss = 'class=other';
                        }
                        var url = URL.createObjectURL(new Blob([data]));
                        console.log("++++++++"+msgcss)
                        let item = "<div "+msgcss+"><span><img class='msgImg' src="+url+" width='100' height='100'></span></div>";
                        $("#talklist").append(item);
                    }
                    //alert($("#talklist").scrollHeight)
                //    console.log($("#talklist").height())
                    //console.log($("#talklist").s)
                    //$("#talklist").scrollTop(300)
                    $("#talklist").scrollIntoView(false)
                }
                 //웹 소켓이 연결되었을 때 호출되는 이벤트
                ws.onopen = function(message){
                    $("#talklist").append("server start...");
                };
                //웹 소켓이 닫혔을 때 호출되는 이벤트
                ws.onclose = function(message){
                    $("#talklist").append("Server Disconnect...\n");
                };
                //웹 소켓이 에러가 났을 때 호출되는 이벤트
                ws.onerror = function(message){

                    $("#talklist").append(message+"error...\n");
                };

            })
            $("#msg").on("keyup",function(ev){
                if(ev.keyCode == 13){
                    sendMessage();
                }

            })
            $("#sendbtn").on("click",function(){
                sendMessage();
            })
            $("#btnclose").on("click",function(){
                ws.close();
            })

        })
        //Send 버튼을 누르면 실행되는 함수
        function sendMessage(){
            mydata.type= "message";
            let message = $("#msg").val();
            //서버로 보낼 데이터 만들기
            mydata.id = $("#id").val();
            mydata.msg = message;
            mydata.date = new Date().toLocaleString();
            let sendmsg = JSON.stringify(mydata);
            //웹소켓으로 textMessage객체의 값을 보낸다.
            ws.send(sendmsg);
            $("#msg").val("");
        }
        function fileSend(){
            var file = document.querySelector("#myimg").files[0];
            var fileReader = new FileReader();
            fileReader.onload = function() {
                mydata.type= "fileUpload",
                mydata.file= file;
                mydata.id = $("#id").val();
                mydata.msg = "";
                mydata.date = new Date().toLocaleString();
                let sendmsg = JSON.stringify(mydata);

                ws.send(sendmsg); //파일 보내기전 메시지를 보내서 파일을 보냄을 명시한다.

                arrayBuffer = this.result;
                console.log(arrayBuffer);
                ws.send(arrayBuffer); //파일 소켓 전송
            };
            fileReader.readAsArrayBuffer(file);
        }
    </script>
</body>
</html>

사진전송 결과보기

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

• HTML5표준기술
• HTTP환경에서 TCP를 통해서 접속해서 통신
• TCP통신을 통해 접속하므로 최초접속시에 3way handshake발생
• 연결유지
• 이벤트발생되고 이 이벤트에 대해서 처리하는 코드를 적용(SSE도 동일)
• 양방향통신(클라이언트에서 요청을 보내지 않아도 서버에서 메시지를 보낼 수 있다)
• 클라이언트는 자바스크립트 코드를 이용해서 작업
• 웹소켓은 Socket Connection을 유지한 상태로 양방향통신을 하면서 실시간 데이터 전 => 텍스트전송, 바이너리전송 모두 가능
• stateful(연결이 유지)
• 클라이언트와 서버가 한 번 연결되면 같은 연결을 통해서 통신하므로 TCP커넥션 비용 절약

[이전방식]

• 폴링 : 일정주기를 가지고 서버의 API를 호출(2초마다 한번씩 호출하기)
• 롱폴링 : 폴링과 비슷, 요청이 서버로 간 후 대기했다가 요청한 데이터가 업데이트되면 서버에서 응답을 보낸다.

==> 리소스도 낭비, 실시간데이터를 주고받는것도 힘들다(채팅,주식,게임,...)

[최근방식]

• 웹소켓
• SSE - 서버에서 웹브라우저로 메시지를 보내는 방법

[웹소켓]

1. 설정

• 웹소켓 통신을 할 수 있도록 객체를 빈으로 만들어서 등록
• ServerEndpointExporter등록 (웹소켓을 사용하기 위해서 필요한 객체)

2. 핸들러작성

• 컨트롤러처럼 웹소켓통신을 할 수 있도록 제공되는 객체
• 클라이언트가 접속하면 클라이언트와 연결, 통신할 수 있도록 제공되는 클래스 클라이언트와 서버가 연결해서 하고싶은 작업은 여기에 정의
• 웹소켓 서버의 역할을 하는 객체(웹소켓 통신할때 요청을 받는 역할)
• endpoint(path)를 등록해야 어떻게 요청하면 서버와 요청할 수 있는지 path를 등록 클라이언트의 요청을 핸들러에서 받아야하는데 클라이언트에서 어떻게 요청하면 핸들러가 동작할지 path를 등록
• 이벤트 드리븐 방식 접속, 메시지전송, 오류, 접속종료 등 이벤트가 발생하면 반응하는 방식
• 웹소켓 내부에서도 세션을 관리할 수 있다. HttpSession과 다른 세션 웹소켓 통신 내부에서 관리하는 세션 웹소켓 통신을 하는 클라이언트를 구분하기 위한 세션

3. 자바스크립트로 클라이언트에서 통신할 코드를 작성

실습

spring initializr

디렉토리 구성

build gradle

application.properties

WebSocketConfig

웹소켓컨테이너를 활성화시키는 작업 - 웹소켓을 사용하겠다고 정의

@Configuration
@EnableWebSocket
public class WebSocketConfig {
    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
}

WebSocketController

@Controller
public class WebSocketController {
    @GetMapping("/chat")
    public String showview(){
        return "chat";
    }
}

WebSocketBasicHandler

웹소켓통신을 하면서 서버역할을 하는 프로그램

@Component
@ServerEndpoint(value = "/chat")
public class WebSocketBasicHandler {
    //세션을 저장하기 위해서 컬렉션을 추가
    //동기화된 컬렉션 - 멀티스레드환경에서 안전하게 작업할 수 있도록 제공되는 set
    private static Set<Session> clientlist = Collections.synchronizedSet(new HashSet<>());

    //클라이언트가 접속을하면 실행되는 메소드
    @OnOpen
    public void open(Session client){
        System.out.println("클라이언트가 접속했다");
        System.out.println(client);
        if (!clientlist.contains(client)){
            clientlist.add(client);
        }
    }
    //클라이언트에게 메시지를 받으면 호출되는 메소드
    //통신할때 메시지를 받으면 호출되는 메소드로 모든 접속자들한테 메시지를 전송할 수 있어야 한다.
    //메시지를 받을때마다 호출되는 메소드
    //텍스트메시지통신(웹소켓에 접속한 모든 클라이언트에게 메시지를 전송)
    @OnMessage
    public void onMessage(String msg,Session sender) throws IOException {
       //웹소켓에 접속한 모든 클라이언트에게 메시지전송
        System.out.println("수신된 메시지:"+msg);
        System.out.println("클라이언트:"+sender);
        for(Session client:clientlist){
            client.getBasicRemote().sendText(msg);
        }
    }
    @OnClose
    //접속종료 - 소켓연결이 끊어지면 호출되는 메소드
    public void onClose(Session client){
        System.out.println("접속종료");
        clientlist.remove(client);
    }
}

chat.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
    <style type="text/css">
        #talklist{
            border:1px solid;
            width: 600px;
            height: 400px
        }
        #msg{
            border:1px solid;
            width: 550px;
            margin-top: 10px
        }
        #sendbtn{
            height: 40px;
            margin-top: 10px;
        }
        #id{
            width: 350px;
            margin-bottom: 10px
        }
        .me{
            background-color: #FAECC5;
            width: 70%;
            float: right;
            margin: 1px
        }
        .other{
            background-color: #EAEAEA;
            width: 70%;
            float: left;
            margin: 1px
        }
    </style>

</head>
<body>
    <div id='chatt'>
        <h1>웹 소켓 채팅</h1>
        <input type='text' id='id' >
        <input type='button' value='채팅참여' id='joinbtn' >
        <input type='button' value='채팅종료' id='btnclose' >
        <br/>
        <div id='talklist'></div>
        <div id='sendZone'>
                <textarea id='msg' ></textarea>
            <input type='button' value='전송' id='sendbtn'>
        </div>
    </div>
    <script type="text/javascript">
        //전송할 데이터가 여러개이므로 json으로 전송
        let mydata = {};

        $(document).ready(function(){
            $("#joinbtn").on("click",function(){
                //alert(location.host);
                //1. 웹소켓객체를 생성 - 서버에 연결하는 작업
                ws = new WebSocket("ws://"+location.host+"/chat");
                //연결이 되면 이벤트에 반응할 수 있도록 콜백등록

                //웹소켓에서 클라이언트로 전송하는 메시지를 받을 수 있도록 처리
                //웹소켓에 연결된 후에 실행
                ws.onopen = function(msg){
                    console.log(msg);
                    $("#talklist").append("<div>접속완료....</div>");
                }
                //웹소켓 연결 후에 서버가 메시지를 보내면 받을 수 있도록 콜백등록
                ws.onmessage = function(msg){
                    //실제 데이터가 json으로 전송
                    console.log(msg.data);
                    //받은 메시지를 출력 - 내가 보낸건지 받은 메시지인지 확인하기 위해서 id하고 비교
                    //전송되는 메시지에서 데이터만 추출
                    //json데이터에 저장된 값을 엑세스하려면 JSON문자열을 parsing해야한다.
                    let resMsg = JSON.parse(msg.data);
                    console.log(resMsg);
                    let msgcss = "";
                    if(resMsg.id==$("#id").val()){//내가 작성한 메시지인지 확인
                        msgcss = "class = me";
                    }else{
                        msgcss = "class = other";
                    }
                    //talklist에 출력할 div생성
                    let item = "<div "+ msgcss+ " ><span><b>"+ resMsg.id+ "</b></span>"
                               + "<b>["+ resMsg.date+ "]</b><br/>"
                               + "<span>"+ resMsg.msg +"</span>"
                               +"</div>"
                    $("#talklist").append(item);
                }
                //웹소켓이 종료된 후에 발생하는 이벤트에 대해서 처리할 수 있도록 콜백등록
                ws.onclose = function(msg){
                    //실제 데이터가 json으로 전송
                    console.log(msg);
                    $("#talklist").append("<div>접속종료....</div>");
                }
                ws.onerror = function(msg){
                    //실제 데이터가 json으로 전송
                    console.log(msg);
                    $("#talklist").append("<div>에러발생....</div>");
                }
            });
            $("#sendbtn").on("click",function(){
                sendMessage();
            })
            $("#msg").on("click",function(event){
                //엔터키가 눌려지면
                if(event.keyCode==13){
                    sendMessage();
                }
            })
            $("#btnclose").on("click",function(){
                //웹소켓연결종료
                ws.close();
            })
        })
        function sendMessage(){
            //메시지전송함수
            //서버로 보낼 메시지를 만들어서 전송
            //지금은 id를 <input>에서 꺼내지만 나중에는 웹의 세션에 저장된 dto에서 꺼내기
            mydata.id = $("#id").val();
            mydata.msg = $("#msg").val();
            mydata.date = new Date().toLocaleDateString();//오늘날짜
            mydata.type = "textmsg";//메시지유형(텍스트와 바이너리를 구분하기 위한 값)

            //자바스크립트 객체로 정의된 데이터를 json문자열로 변환
            let sendMsg = JSON.stringify(mydata);
            ws.send(sendMsg);//웹소켓서버로 메시지를 전송
            $("#msg").val("");//메시지전송이 완료되면 텍스트창을 지우기
        }
    </script>
</body>
</html>

결과

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

(강사님이 만드신거)

application properties에서 url, ConnectionTest에서 url,sql문 변경

putty 접속

putty에서 공인ip로 연결해서 패스워드 적어둔거 우클해서 접속

명령어정리

root@myserver3-1:~#

• ~ : 홈디렉토리

• / : 최상위디렉토리로 이동(루트디렉토리)

• #: 관리자계정

• $ : 일반 사용자 계정

리눅스폴더

• /home : 각 사용자들의 홈디렉토리가 만들어지는 위치

• ** 홈디렉토리 : 특정 사용자 계정으로 로그인했을때 자동으로 위치하는 디렉토리, 모든 사용자는 자신만의 홈디렉토리를 갖는다.

• /boot : 부팅에 필요한 설정파일이 위치하는 폴더

• /bin : shell명령어가 위치한 폴더

• /etc : 시스템관리를 위해서 필요한 각종 설정 파일이 위치하는 곳 네트워크, 사용자, 파일시스템, 설치한 각종 프로그램의 설정파일...

• /usr : 윈도우의 programfiles와 유사

리눅스명령어

• pwd : 현재 위치확인

• cd : 폴더이동 cd ~ : root로 이동

• ls : 도스명령어의 dir과 동일, 폴더 안에 어떤 내용이 들어있는지 보기 위해서 사용

• mkdir : 디렉토리 만들기 mkdir 디렉토리명

• touch : 빈파일 만들기 touch 파일명

• cp : 파일복사

• 디렉토리에서 다른 디렉토리로 복사*하는 경우 cp 파일명 복사할위치

• 디렉토리를 복사* cp 복사할디렉토리경로 대상디렉토리 cp ./test(소스디렉토리) test2(타겟디렉토리)

• scp : 복사(내머신-> 다른머신으로 복사) 호스트에서 다른 호스트로 복사하는 경우(윈10버전부터 사용할 수 있도록 지원)

• rm : 파일삭제 rm 삭제할파일

• rm : 폴더삭제 rm -r 폴더명

• scp 호스트 -> 호스트로 카피(디렉토리, 파일) scp 복사할파일명(위치포함)(나의호스트) 대상위치(위치포함)(상대방호스트 : 계정@ip:/경로) scp ./ljh root@223.130.157.214:/root/exam

[미션]

• myfile1, myfile2, myfile3 파일을 3개 생성하기
• mytest폴더생성
• mytest폴더로 3개의 파일을 복사
• mytest폴더에 sub폴더 생성
• mytest폴더의 내용을 확인

파일 만들어서 다른 ip로 보내기

[배포하기]

1. jar파일로 패키징

2. scp명령어를 이용해서 서버로 복사

3. 실행

• os내부의 패키지(소프트웨어) 업데이트 sudo apt update

• java설치 sudo apt install openjdk-17-jdk

• 실행 java -jar erp-0.0.1-SNAPSHOT.jar

localhost자리에 해당 ip넣기

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

https://m.blog.naver.com/heaves1/223424605755 참고사이트 링크

VPC생성

Network ACL생성

Network ACL 규칙설정

인바운드 포트는 팀프로젝트 포트 아웃바운드포트는 아무나 다 가능하게하는(?) 1-65535

서브넷 생성

ACG 생성

ACG 규칙설정

인바운드 아웃바운드

서버생성

1,2단계는 다시.. 지금은 연습이라 다르게했음 인증키 설정 네트워크 접근설정 선택한거 확인

공인IP신청

확인

DB

acg

intelliJ erp와 연결해보기

ConnectionTest

public class ConnectionTest {
    public static void main(String[] args) {
        String url="jdbc:mysql://db-nttta-kr.vpc-pub-cdb.ntruss.com:3306/test?serverTimezone=UTC";
        String user="myerp";
        String password="myerp2024!";
        try {
            //1. 드라이버로딩
            Class.forName("com.mysql.cj.jdbc.Driver");
            System.out.println("드라이버로딩성공!!");
            //2. 연결
            Connection con = DriverManager.getConnection(url, user, password);
            PreparedStatement ptmt =  con.prepareStatement("select * from TBBOARD");
            ResultSet rs =  ptmt.executeQuery();
            while (rs.next()){
                System.out.println(rs.getString(1));
            }
            System.out.println("연결성공!!"+con);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

implementation 'org.springframework.security:spring-security-crypto:5.7.1'

PasswordConfig 생성

@Configuration
public class PasswordConfig {
    //PasswordEncoder : 패스워드 암호화를 위해 제공되는 상위클래스
    //PasswordEncoder객체를 만들어서 제공
    @Bean
    public PasswordEncoder passwordEncoder(){
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
}

register 변경 - 인원등록부분

MemberController

편의상 변경된 사항만 기입

@Controller
@RequestMapping("/member")
@SessionAttributes("user")
@RequiredArgsConstructor
public class MemberController {
    private final MemberService service;
    private final DeptService deptservice;
    private final FileUploadService fileuploadService;
    private final PasswordEncoder passwordEncoder;


//    스프링에서 제공되는 기능을 이용해서 로그인 처리하기
    @PostMapping("/spring/login")
    public String springlogin(MemberDTO loginUserInfo, Model model) {
        System.out.println("스프링이 제공하는 @SessionAttributes를 이용해서 로그인");
        MemberDTO user = service.login(loginUserInfo);
        System.out.println("------------로그인한 사용자정보:"+user);
        String view = "";

        /*
        passwordEncoder.matches(loginUserInfo.getPass(), user.getPass())
                                ----------------------    ---------------
                                로그인하며 사용자가 입력한 값     디비에서 조회한 사용자의 패스워드값
        => 로그인하며 사용자가 입력한 값을 암호화하고 디비에 저장된 값을 비교해서 일치하면 true 아니면 false
        */
        if(user!=null & passwordEncoder.matches(loginUserInfo.getPass(), user.getPass())) {
            System.out.println("패스워드 일치");
            model.addAttribute("user",user);
            view = "emp/mypage";//타임리프쓰니 서브메뉴로 로그인했을때 각 부서 정의해놓음
        }else {
            System.out.println("패스워드 불일치");
            view = "redirect:/emp/login.do";
        }

        /*
        암호화하기 전의 로그인
        if(user!=null) {
            //로그인성공
            model.addAttribute("user",user);
            view = "emp/mypage";//타임리프쓰니 서브메뉴로 로그인했을때 각 부서 정의해놓음
        }else {
            //로그인실패
            view = "redirect:/emp/login.do";
        }*/

        return view;
    }


    @GetMapping("/insert")
    public String insert(Model model) {
        //기존의 DeptServiceImpl의 셀렉트메소드를 호출해서 결과를 공유
        List<DeptDTO> deptlist = deptservice.select();
        model.addAttribute("deptlist",deptlist);
        return "emp/register";
    }
    @PostMapping("/insert")
    public String insertPage(MemberDTO member, HttpSession session) 
                                        throws IllegalStateException, IOException{
        //패스워드 암호화
        String encodedPass = passwordEncoder.encode(member.getPass());
        System.out.println("-----------"+encodedPass);

        //암호화된 패스워드 세팅
        member.setPass(encodedPass);


        System.out.println(member);
        //1. 파일업로드
        MultipartFile file = member.getUserImage();
        String path = WebUtils.getRealPath(session.getServletContext(), "/WEB-INF/upload");
        String storeFilename = fileuploadService.uploadFile(file);
        member.setProfile_photo(storeFilename);
        member.setGender("0");
        System.out.println(member);
        //2.디비에 저장하기
        service.insert(member);

        return "emp/register";
    }

}

member 매퍼 변경

DB수정

암호화된 패스워드가 등록되니 패스워드 길이 변경

입력결과

password자리에 암호화된 키 삽입됨

수업현황 및 기타

• 팀프로젝트 진행으로 필요한 부분만 추출해서 수업해주심
• spring security + redis(메모리 db) + kafka(비동기통신) 과정 끝나고 공부할 것 권장 => (프론트독립, 스케일아웃, MSA(서비스단위분리)로 보안처리 강화에 필요)
• 암호화한 것은 복호화할 수 없음
• 토큰과 세션..
• 로그인정책
  • 사용자가 입력한 아이디 이용하여 사용자 조회
  • 사용자가 입력한 패스워드를 암호화하여 맵에 지정된 패스워드와 일치하는지 조회

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

//api패키지의 모든 컨트롤러는 RestController
//JSON을 리턴하는 메소드
@RestController
@RequiredArgsConstructor
@RequestMapping("/api")
//로그기록
@Slf4j
public class CategoryAPIController {
    private final CategoryService categoryService;
    //카테고리를 추가하기 위한 데이터를 JSON으로 입력받고 싶은 경우
    //JSON으로 입력데이터를 만들어서 요청하면 스프링이 DTO로 변환
    //작업이 완료되면 성공완료됐는지만 넘기기
    //@RequestBody ---> json데이터 -> DTO로 변환해서 매개변수에 전달
    //@RequestBody ---> 자바객체 -> json데이터로 변환해서 응답
    @PostMapping("/category/insert")
    public ResponseEntity<?> insert(@RequestBody CategoryRequestDTO inputdata){
        System.out.println(inputdata);
        categoryService.write(inputdata);
        //ResponseEntity는 상태코드와 응답데이터의 본문을 설정
        //성공응답을 200 응답을 생성하고 별도의 본문없이 응답을 반환 - ok메시지
       // return ResponseEntity.ok().build(); ->원래 이렇게하면됨 밑은 ok사인 찍고싶어서하는것
        return ResponseEntity.ok(HttpStatus.OK);
    }
    @GetMapping("/category/{categoryId}")
    public CategoryResponseDTO read(@PathVariable("categoryId") String catrgoryId){
        return categoryService.findById(Long.parseLong(catrgoryId));
    }

    //뷰가 없어서 처리결과를 JSON으로 만들어서 리턴 - Ajax요청결과
    //뷰로 response하는 경우는 String(뷰) 리턴하고 결과를 Model에 add시킨다.
    @GetMapping("/category/list")
    public List<CategoryResponseDTO> list(){
        return categoryService.findAll();
    }

    @GetMapping("/category/pagelist")
    public List<CategoryResponseDTO> pagelist(){
        return categoryService.pagingFindAll();
    }
}

CategoryRepository

//Repository인터페이스는 내부적으로 구현체를 스프링프레임워크에서 제공하므로 이 자체가 DAO의 역할을 할 수 있다.
//서비스단에서 Repository를 직접 호출해서 사용할 수 있다(프로젝트의 규모가 작은곳)
// view -> controller -> service -> repository

//규모가 큰 프로젝트 같은 경우 view -> controller -> service -> dao -> repository순서로 호출
public interface CategoryRepository extends JpaRepository<CategoryEntity,Long> {
    //로그인 - 컬럼이 id와 pass라 가정(and조건)
    //CategoryEntity findByIdAndPass(String id, String pass);
    List<CategoryEntity> findByCategoryNameContaining(String categoryName);
    //categoryName컬럼이 매개변수로 시작하는 경우 조회
    List<CategoryEntity> findByCategoryNameStartingWith(String categoryName);
    //위의 메소드와 동일한데 페이징처리를 하고싶은 경우
    Page<CategoryEntity> findByCategoryNameStartingWith(String categoryName, Pageable pageRequest);
    Slice<CategoryEntity> findByInfoStartingWith(String info, Pageable pageRequest);
}

CategoryDAOImpl

@Repository
@RequiredArgsConstructor
public class CategoryDAOImpl implements CategoryDAO{
    //스프링프레임워크가 CategoryRepository의 구현체를 만들어서 autowired한다.
    private final CategoryRepository repository;

    @Override
    public void write(CategoryEntity category) {
        //create
        repository.save(category);
    }

    @Override
    public List<CategoryEntity> findAll() {
        //List
        return repository.findAll();
    }

    @Override
    public List<CategoryEntity> pagingFindAll() {
        //페이징처리
        //1. Pageable객체만들기
        //2. repository의 페이징메소드 호출
        //3. 리턴되는 Page객체에서 List에 저장된 Entity추출하기

        //셋팅해야하는 값들을 매개변수로 전달받아서 셋팅 - pageNumber
        PageRequest pageRequest = PageRequest.of(0, 5, Sort.by(Sort.Direction.DESC, "categoryId"));
        Page<CategoryEntity> page =repository.findAll(pageRequest);
        System.out.println("-----------------------");
        System.out.println("전체레코드수=>"+page.getTotalElements());
        System.out.println("페이지수=>"+page.getTotalPages());
        System.out.println("조회한 레코드수=>"+page.getNumberOfElements());
        System.out.println("한페이지사이즈=>"+page.getSize());
        System.out.println("-----------------------");
        return page.getContent();
    }

    @Override
    public CategoryEntity findById(long categoryId) {
        //read
        return repository.findById(categoryId).get();
    }
}

CategoryServiceImpl

@Service
@RequiredArgsConstructor
public class CategoryServiceImpl implements CategoryService{
    private final CategoryDAO dao;
    @Override
    public void write(CategoryRequestDTO category) {
        //컨트롤러에서 넘겨받은 CategoryRequestDTO를 entity로 변환해서 넘기기
        //step01 - 생성자를 이용해서 직접 변경
        //CategoryEntity entity = new CategoryEntity(category.getCategoryName(),category.getInfo());
        ModelMapper mapper = new ModelMapper();
        //CategoryRequestDTO가 CategoryEntity로 자동변환
        CategoryEntity entity = mapper.map(category,CategoryEntity.class);
        dao.write(entity);
    }

    @Override
    public List<CategoryResponseDTO> findAll() {
        List<CategoryEntity> entityList = dao.findAll();
        //Entity를 뷰로 넘기면 안된다. entity를 DTO로 변환
        //step3 스트림으로 변환해서 작업
        //=> 스트림은 자바8부터 도입된 API로 컬렉션의 요소를 하나씩 참조해서 여러가지 변환작업이 가능하거나 람다식을 반복처리할 수 있도록 편리한 기능을 제공
        //1. 스트림으로 변환
        //2. 데이터가공 -중간연산
        //map() -> 스트림이 갖고있는 각 요소를 원하는 메소드나 생성자 등을 적용해서 변환할 수 있다.
        // 클래스명 :: 메소드명
        // 클래스명 :: new
        //=> :: 연산자를 통해 new를 참조하는 경우에는 해당 생성자가 미리 만들어져 있다는 것을 전제
        //3. 변환된 요소를 새로운 리스트로 만드는 작업
        List<CategoryResponseDTO> categoryList = entityList.stream()
                                                .map(CategoryResponseDTO :: new)
                                                .collect(Collectors.toList());
        return categoryList;
    }

    @Override
    public List<CategoryResponseDTO> pagingFindAll() {
        //dao의 메소드를 호출하고 데이터를 변환
        List<CategoryEntity> entityList = dao.pagingFindAll();
        //step4. 스트림으로 변환(ModelMapper를 이용)
        ModelMapper mapper = new ModelMapper();
        List<CategoryResponseDTO> categorylist = entityList.stream()
                .map(entity -> mapper.map(entity, CategoryResponseDTO.class))
                .collect(Collectors.toList());
        return categorylist;
    }

    @Override
    public CategoryResponseDTO findById(long categoryId) {
        //Entity를 DTO로 변환해서 넘기기
        //step2 builder를 활용해서 작업하기
        CategoryEntity entity = dao.findById(categoryId);

        return CategoryResponseDTO.builder()
                .categoryId(entity.getCategoryId())
                .categoryName(entity.getCategoryName())
                .info(entity.getInfo())
                .build();
    }
}

CategoryDAOImplTest

@SpringBootTest
@Transactional
@Rollback(value = false)
class CategoryDAOImplTest {
    @Autowired
    CategoryRepository repository;

    @Test
    public void test1(){
        CategoryEntity category1 = new CategoryEntity("셔츠","블라우스포함");
        CategoryEntity category2 = new CategoryEntity("가방","자체제작");
        CategoryEntity category3 = new CategoryEntity("팬츠","반바지포함");
        CategoryEntity category4 = new CategoryEntity("악세사리","목걸이, 리본포함");
        //한꺼번에 insert
        repository.saveAll(Lists.newArrayList(category1,category2,category3,category4));

    }

    @Test
    public void test2(){
        //update
        //1. 수정할레코드를 조회
        CategoryEntity category = repository.findById(2L).get();
        System.out.println(category);

        //2. setter메소드를 호출해서 변경
        category.setCategoryName("후드티");
        category.setInfo("스투시와 나이키");

        //3.save호출
        //save메소드는 객체를 새롭게 만들어서 작업하는 경우 insert문이 만들어지고
        //조회된 객체의 setter메소드를 호출해서 값을 변경하는 경우에는 update문이 만들어진다.
        //=>JPA내부에서 최초로 만들어진 객체의 이미지를 저장하고 있다가 변경되면 update호출
        repository.save(category);
    }

    @Test
    public void test3(){
        List<CategoryEntity> list = repository.findByCategoryNameContaining("가");
        System.out.println(list);
    }
}

https://docs.spring.io/spring-data/jpa/reference/jpa/query-methods.html

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.

DeptEntity

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "mydept")
public class DeptEntity {
    @Id
    @GeneratedValue
    @Column(name = "deptNo")
    private Long id;
    private String name;
    private String mgr;
    //양방향관계에서는 항상 기준이 되는 엔티티는 외래키 테이블을 표현한 엔티티
    //현테이블과 매핑되는 테이블이 엔티티에서 어떤 컬럼명으로 명시되어 있는지 정의
    //양방향에서는 mappedBy 속성을 이용해서 내가 뭐에 의해서 매핑이 됐는지 명시
    //상대엔티티에서 현 엔티티를 매핑하고 있는 변수명을 정의
    //mappedBy가 정의되어있는 엔티티에서는 조회만 가능하도록 처리
    @OneToMany(mappedBy = "dept")
    //양방향참조에서 toString을 호출하면 순환참조오류가 발생한다.
    //dept에서 emp의 toString을 호출하고 emp에서 dept의 toString을 호출한다.
    //직접호출하지않아도 JSON객체를 만들때 내부에서 toString을 호출하는 상황이 만들어진다.
    @ToString.Exclude //toString메소드에 해당컬럼을 포함하지 않겠다는 의미
    private List<EmpEntity> emplist = new ArrayList<>();

    public DeptEntity(String name, String mgr) {
        this.name = name;
        this.mgr = mgr;
    }
}

EmpEntity

//단방향으로 작업
@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "myemp")
public class EmpEntity extends PublicInfoEntity {
    @Id
    private String userId;
    private String name;
    private String addr;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "userPrivateId")
    private PrivateInfoEntity infoEntity;


    public EmpEntity(String userId, String name, String addr, PrivateInfoEntity infoEntity) {
        this.userId = userId;
        this.name = name;
        this.addr = addr;
        this.infoEntity = infoEntity;
    }

    //경력사항은 한 사람이 여러 개 가질 수 있다.
    @OneToMany(mappedBy = "emp", cascade = CascadeType.ALL)
//    @JoinColumn(name = "userKey")
    private List<HistoryEntity> historylist = new ArrayList<>();

    @ManyToOne
    @JoinColumn(name = "deptId")
    private DeptEntity dept;

    //양방향관계에서 주데이터 이외의 새로 추가된 데이터가 반영된다.
    public void changeVal(HistoryEntity history){
        historylist.add(history);
        history.setEmp(this);
    }

    //모든정보를 Emp에 저장하기
    //양방향관계에서 기본객체가 아닌 객체도 데이터가 반영될 수 있도록 처리하기
    public static EmpEntity buildEmpEntity(String userId, String name, String addr,
                                           PrivateInfoEntity infoEntity, List<HistoryEntity> historylist, DeptEntity dept){
        EmpEntity entity = new EmpEntity(userId,name,addr,infoEntity,dept);
        //historylist에서 history를 꺼내서 emp를 셋팅
        for (HistoryEntity history:historylist){
            entity.changeVal(history);
        }
        return entity;
    }

    public EmpEntity(String userId, String name, String addr, PrivateInfoEntity infoEntity, List<HistoryEntity> historylist) {
        this.userId = userId;
        this.name = name;
        this.addr = addr;
        this.infoEntity = infoEntity;
        this.historylist = historylist;
    }

    public EmpEntity(String userId, String name, String addr, PrivateInfoEntity infoEntity, DeptEntity dept) {
        this.userId = userId;
        this.name = name;
        this.addr = addr;
        this.infoEntity = infoEntity;
        this.dept = dept;
    }
}

HistoryEntity

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "myhistory")
public class HistoryEntity {
    @Id
    @GeneratedValue
    private Long historyId;
    private String company;
    private String content;

    @ManyToOne
    @JoinColumn(name = "id")
    private EmpEntity emp;

    public HistoryEntity(String company, String content) {
        this.company = company;
        this.content = content;
    }
}

JPAWayTest

@SpringBootTest
@Transactional
@Rollback(value = false)
class JPAWayTest {
    @PersistenceContext
    EntityManager entityManager;

    @Test
    public void test1() {
        //초기데이터 저장하기
        DeptEntity dept1 = new DeptEntity("전산실", "RM");
        DeptEntity dept2 = new DeptEntity("인사팀", "슈가");
        DeptEntity dept3 = new DeptEntity("기획실", "뷔");

        entityManager.persist(dept1);
        entityManager.persist(dept2);
        entityManager.persist(dept3);
        //사원을 등록할 때 경력 사항을 같이 등록하기
        //파라미터로 전달 받은 부서 코드를 이용해서 부서 정보 조회
        PrivateInfoEntity privateInfo1 =
                new PrivateInfoEntity("bts1", "태양과 듀엣", "솔로");
        PrivateInfoEntity privateInfo2 =
                new PrivateInfoEntity("bts2", "Seven", "올림픽곡");
        PrivateInfoEntity privateInfo3 =
                new PrivateInfoEntity("bts3", "춤모야", "조교");
        PrivateInfoEntity privateInfo4 =
                new PrivateInfoEntity("bts4", "제대했다", "너무해");
        PrivateInfoEntity privateInfo5 =
                new PrivateInfoEntity("kbr", "싱어송라이터", "바람바람바람");

        //경력사항 3개
        List<HistoryEntity> historyEntityList = new ArrayList<>();
        historyEntityList.add(new HistoryEntity("A사", "front개발"));
        historyEntityList.add(new HistoryEntity("B사", "Entity개발"));
        historyEntityList.add(new HistoryEntity("C사", "보안"));


        EmpEntity emp1 = new EmpEntity("bts1", "지민", "광주"
                , privateInfo1, historyEntityList, dept1);
        EmpEntity emp2 = new EmpEntity("bts2", "정국", "부산", privateInfo2, dept1);
        EmpEntity emp3 = new EmpEntity("bts3", "제이홉", "광주", privateInfo3, dept2);
        EmpEntity emp4 = new EmpEntity("bts4", "석진", "천안", privateInfo4, dept2);
        EmpEntity emp5 = new EmpEntity("kbr", "범룡", "청주", privateInfo5, dept3);

        entityManager.persist(emp1);
        entityManager.persist(emp2);
        entityManager.persist(emp3);
        entityManager.persist(emp4);
        entityManager.persist(emp5);

    }

    @Test
    public void test2() {
        //dept데이터 조회하기 : Dept -> Emp
        //ctrl+alt+L
        //1번부서
        DeptEntity deptEntity = entityManager.find(DeptEntity.class, 1L);
        System.out.println(deptEntity);

        //양방향은 양쪽의 모든 엔티티에서 각자방향으로 객체를 접근할 수 있다.
        List<EmpEntity> emplist = deptEntity.getEmplist();
        for (EmpEntity emp : emplist) {
            System.out.println(emp + "=>" + emp.getDept());
        }
    }

    @Test
    public void test3() {
        //emp조회 : Emp -> Dept
        EmpEntity empEntity = entityManager.find(EmpEntity.class, "bts1");
        System.out.println(empEntity);
        System.out.println(empEntity.getDept().getName());
    }

    @Test
    public void test4() {
        //새로운 사원을 등록
        DeptEntity dept = entityManager.find(DeptEntity.class, "2");
        System.out.println(dept);
        List<HistoryEntity> historyEntityList = new ArrayList<>();

        historyEntityList.add(new HistoryEntity("D사", "front react개발"));
        historyEntityList.add(new HistoryEntity("E사", "Entity개발"));
        historyEntityList.add(new HistoryEntity("A사", "보안개발"));

        EmpEntity emp = new EmpEntity("bts7", " 슈가", "대구",
                new PrivateInfoEntity("bts7", "화양연화", "래퍼"),
                historyEntityList, dept);
        entityManager.persist(emp);
    }

    @Test
    public void test5() {
        //새로 삽입된 데이터를 조회하기 - Emp기준
        EmpEntity empEntity = entityManager.find(EmpEntity.class, "bts7");
        System.out.println("bts7의 부서정보=>"+empEntity.getDept());
    }

    @Test
    public void test6() {
        //새로 삽입된 데이터를 조회하기 - Dept 기준
        DeptEntity deptEntity = entityManager.find(DeptEntity.class, 2L);
        System.out.println(deptEntity);

        //양방향은 양쪽의 모든 엔티티에서 각자방향으로 객체를 접근할 수 있다.
        List<EmpEntity> emplist = deptEntity.getEmplist();
        for (EmpEntity emp : emplist) {
            System.out.println(emp.getUserId());
        }
    }
    @Test
    public void test7() {
        //양방향으로 매핑되어있는 객체는
        //방향시 연관관계에서 주인이 아닌 역방향에 관계를 설정해서 코드를 넣지 않는다.
        // - mapped by 가 정의되어있는 엔티티는 조회만한다.
        //주체가 아닌 것을 이용해서 insert를 했기 때문에 dept가 셋팅되지 않는다.
        EmpEntity emp = new EmpEntity("bts5", " 뷔", "서울",
                new PrivateInfoEntity("bts5", "화랑", "서진이네"));
        entityManager.persist(emp);

        DeptEntity dept = new DeptEntity("TF팀","kbr");
        dept.getEmplist().add(emp);
        entityManager.persist(dept);
    }

    @Test
    public void test8() {
        DeptEntity dept = new DeptEntity("서비스팀","장동건");
        entityManager.persist(dept);

        EmpEntity emp = new EmpEntity("bts7", "슈가", "대구",
                new PrivateInfoEntity("bts7", "화양연화", "래퍼"),dept);
        entityManager.persist(emp);
    }

    @Test
    public void test9() {
        DeptEntity dept = entityManager.find(DeptEntity.class, "2");
        System.out.println(dept);
        List<HistoryEntity> historyEntityList = new ArrayList<>();

        historyEntityList.add(new HistoryEntity("D사", "front react개발"));
        historyEntityList.add(new HistoryEntity("E사", "Entity개발"));
        historyEntityList.add(new HistoryEntity("A사", "보안개발"));

        //주객체와 양방향매핑되는 객체에 변경된 내용을 반영시키기
        EmpEntity emp = EmpEntity.buildEmpEntity("lee2", "이민호", "서울",
                new PrivateInfoEntity("lee2", "신의", "푸른바다의전설"),
                historyEntityList, dept);
        entityManager.persist(emp);
    }
}

적용실습 in erp

디렉토리구조

CategoryController

//view를 랜더링하는 컨트롤러
@Controller
@RequestMapping("/category")
@RequiredArgsConstructor
public class CategoryController {
    private final CategoryService service;
    //page보기
    @GetMapping("write")
    public String categoryRegisterPage(){
        return "manage/product/category";
    }
    @PostMapping("write")
    public String categoryRegister(CategoryRequestDTO inputdto){
        System.out.println(inputdto);
        service.write(inputdto);
        return "manage/product/category";
    }
}

category.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
      layout:decorate="~{layout/mainLayout}">
<head>
    <meta charset="UTF-8">
    <title>Insert title here</title>

</head>

<body>
<div class="container-fluid" layout:fragment="content">
    <h1>카테고리 등록</h1>
    <hr/>
    <form  class="form-horizontal"  action="/erp/category/write"   method="POST" name="myform">
        <fieldset>
            <div class="form-group">
                <!-- 카테고리명-->
                <div><a href="/erp/catgory/list">카테고리목록</a></div>
            </div>
            <div class="form-group">
                <!-- 카테고리명-->
                <label class="control-label col-sm-2" for="categoryName">카테고리명</label>
                <div class="col-sm-3">
                    <input type="text" id="categoryName" name="categoryName"
                           placeholder="카테고리명"
                           class="form-control"  >

                </div>
            </div>
            <div class="form-group">
                <!-- 비고-->
                <label class="control-label col-sm-2" for="info">비고</label>
                <div class="col-sm-3">
                    <input type="text" id="info" name="info"
                           placeholder="비고"
                           class="form-control"  >

                </div>
            </div>
            <div class="form-group">
                <!-- Button -->
                <div class="col-sm-3 col-sm-offset-2">
                    <input type="submit" value="등록하기" class="btn btn-success"/>
                </div>
            </div>
        </fieldset>
    </form>
</div>
</body>
</html>

CategoryDAOImpl

@Repository
@RequiredArgsConstructor
public class CategoryDAOImpl implements CategoryDAO{
    //스프링프레임워크가 CategoryRepository의 구현체를 만들어서 autowired한다.
    private final CategoryRepository repository;

    @Override
    public void write(CategoryEntity category) {
        //create
        repository.save(category);
    }

    @Override
    public List<CategoryEntity> findAll() {
        //List
        return repository.findAll();
    }

    @Override
    public List<CategoryEntity> pagingFindAll() {
        return List.of();
    }

    @Override
    public CategoryEntity findById(long categoryId) {
        //read
        return repository.findById(categoryId).get();
    }
}

CategoryServiceImpl

@Service
@RequiredArgsConstructor
public class CategoryServiceImpl implements CategoryService{
    private final CategoryDAO dao;
    @Override
    public void write(CategoryRequestDTO category) {
        //컨트롤러에서 넘겨받은 CategoryRequestDTO를 entity로 변환해서 넘기기
        //step01 - 생성자를 이용해서 직접 변경
        CategoryEntity entity = new CategoryEntity(category.getCategoryName(),
                                                 category.getInfo());
        dao.write(entity);
    }

    @Override
    public List<CategoryResponseDTO> findAll() {
        return List.of();
    }

    @Override
    public List<CategoryResponseDTO> pagingFindAll() {
        return List.of();
    }

    @Override
    public CategoryResponseDTO findById(long categoryId) {
        //Entity를 DTO로 변환해서 넘기기
        //step2 builder를 활용해서 작업하기
        CategoryEntity entity = dao.findById(categoryId);

        return CategoryResponseDTO.builder()
                .categoryId(entity.getCategoryId())
                .categoryName(entity.getCategoryName())
                .info(entity.getInfo())
                .build();
    }
}

CategoryResponseDTO

@AllArgsConstructor
@NoArgsConstructor
@Data
@Builder
public class CategoryResponseDTO {
    private Long categoryId;
    private String categoryName;
    private String info;
}

CategoryRequestDTO

@AllArgsConstructor
@NoArgsConstructor
@Data
@Builder
public class CategoryRequestDTO {
    private String categoryName;
    private String info;

}

CategoryEntity

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "category")
public class CategoryEntity {
    @Id
    @GeneratedValue
    private Long categoryId;
    private String categoryName;
    private String info;

    public CategoryEntity(String categoryName, String info) {
        this.categoryName = categoryName;
        this.info = info;
    }
}

CategoryAPIController

//api패키지의 모든 컨트롤러는 RestController
//JSON을 리턴하는 메소드
@RestController
@RequiredArgsConstructor
@RequestMapping("/api")
//로그기록
@Slf4j
public class CategoryAPIController {
    private final CategoryService categoryService;
    //카테고리를 추가하기 위한 데이터를 JSON으로 입력받고 싶은 경우
    //JSON으로 입력데이터를 만들어서 요청하면 스프링이 DTO로 변환
    //작업이 완료되면 성공완료됐는지만 넘기기
    //@RequestBody ---> json데이터 -> DTO로 변환해서 매개변수에 전달
    //@RequestBody ---> 자바객체 -> json데이터로 변환해서 응답
    @PostMapping("/category/insert")
    public ResponseEntity<?> insert(@RequestBody CategoryRequestDTO inputdata){
        System.out.println(inputdata);
        categoryService.write(inputdata);
        //ResponseEntity는 상태코드와 응답데이터의 본문을 설정
        //성공응답을 200 응답을 생성하고 별도의 본문없이 응답을 반환 - ok메시지
       // return ResponseEntity.ok().build(); ->원래 이렇게하면됨 밑은 ok사인 찍고싶어서하는것
        return ResponseEntity.ok(HttpStatus.OK);
    }
    @GetMapping("/category/{categoryId}")
    public CategoryResponseDTO read(@PathVariable("categoryId") String catrgoryId){
        return categoryService.findById(Long.parseLong(catrgoryId));
    }
}

본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.