• 스마트폰 앱 이용자에게 접근권한에 대한 내용을 고지하고 동의절차를 준수하도록 하기 위해

1. 접근권한 안내 고지 및 고지-설치 권한 일치 여부

2. 접근권한 필수/선택 구분에 관련한 사항 고지

   → 위 두 사항을 충족하도록 구현함

• 필수 항목 - 위치, 카메라 권한 / 선택 항목 - 캘린더 접근 권한
• 위치 : 건물/길 찾기 (앱 첫 화면)
• 카메라 : Barcode scanner, QR scanner
• 캘린더

위치 접근 권한 허용

• 앱 최초 실행 시 첫 화면에 접근 권한 허용 여부 묻기
• 허용 거부 시, 설정으로 이동하여 허용하도록 함
• 첫 화면에 구현하기 위해 MainViewController에 코드 작성

//위치 권한 접근 (필수적)
func requestLocationAccess() {
       locationManager.delegate = self
       locationManager.requestWhenInUseAuthorization()
}

func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
   switch status {
   case .authorizedWhenInUse, .authorizedAlways:
       print("위치 권한 허용됨")
   case .denied, .restricted:
       print("위치 권한 거부됨")
       self.presentPermissionAlert(title: "위치 접근 권한 필요", message: "앱이 위치를 확인하려면 권한이 필요합니다.")
   default:
       break
    }
 }

캘린더 접근 권한 허용

• 앱 최초 실행 시 첫 화면에 접근 권한 허용 여부 묻기
• 첫 화면에 구현하기 위해 MainViewController에 코드 작성

//캘린더 권한 접근 (선택적)
func requestCalendarAccess() {
    let eventStore = EKEventStore()

    eventStore.requestAccess(to: .event) { (granted, error) in
        DispatchQueue.main.async {
            if granted {
                print("캘린더 권한 허용됨")
            } else {
                print("캘린더 권한 거부됨")
            }
        }
    }
}

카메라 접근 권한 허용

• BarcodeScannerViewController에 코드 작성

// 카메라 권한 상태 확인 후 요청
AVCaptureDevice.requestAccess(for: .video) { response in
    if !response {
        DispatchQueue.main.async {
            self.presentPermissionAlert(
                title: "카메라 권한 필요",
                message: "카메라 사용 권한이 비활성화되어 있습니다. 설정에서 권한을 활성화하세요."
            )
        }
    }
}

// 카메라 권한 거부 시 설정으로 이동하는 알림
private func presentPermissionAlert(title: String, message: String) {
    let alertController = UIAlertController(title: title, message: message, preferredStyle: .alert)
    alertController.addAction(UIAlertAction(title: "설정으로 이동", style: .default, handler: { _ in
        guard let settingsURL = URL(string: UIApplication.openSettingsURLString) else { return }
    UIApplication.shared.open(settingsURL)
    }))
    alertController.addAction(UIAlertAction(title: "취소", style: .cancel, handler: nil))
    present(alertController, animated: true, completion: nil)
}

접근 권한 필수/선택 구분에 관련한 사항 고지

• 앱 최초 실행 시 1회만 접근 권한 (필수/선택) 구분 사항 고지

//필수, 선택적 권한 고지
func showPermissionNotice() {
    // 최초 실행인지 확인
    if !UserDefaults.standard.bool(forKey: "hasShownPermissionNotice") {

        DispatchQueue.global(qos: .background).async {
            DispatchQueue.main.async {
                let alertController = UIAlertController(
                    title: "접근 권한 안내",
                        message:  """
                       팝업에 원하는 문구 넣기
                        """,
                    preferredStyle: .alert
                )

                alertController.addAction(UIAlertAction(title: "종료", style: .default, handler: { _ in
                    self.requestLocationAccess()
                    self.requestCalendarAccess()
                }))

                alertController.addAction(UIAlertAction(title: "확인", style: .default, handler: { _ in
                    self.requestLocationAccess()
                    self.requestCalendarAccess()
                    UserDefaults.standard.set(true, forKey: "hasShownPermissionNotice")
                }))

                self.present(alertController, animated: true, completion: nil)
            }
        }
    }
}

//viewDidLoad 함수 내
        if isFirstLaunch() {
            showPermissionNotice()
        }

Finally

각 접근 권한 허용 팝업, 필수/선택적 허용 팝업 구현 후 어플 배포 완료

barcode scanner zoom기능 구현

개요

관리하는 어플 내 barcode scanner 에서 아이폰 14 pro, 15 pro와 같이 카메라가 3개 이상인, 즉 광각모드를 지원하는 기기의 경우 바코드를 가까이 댔을 때 초점을 잃어 스캔하지 못하는 기기자체의 오류 발생 → 멀리서 초점은 맞춰지지만 바코드끼리 겹쳐져서 인식이 안되는 문제가 발생하는 것

그래서 든 생각은?

• 가까이서 인식이 안되면 멀리서 인식해서 zoom in 하는 것은 어떨까? 였다!

가장 먼저, 카메라 기본 권한설정 필수 (info-필요권한주기)

• (key 지정 후 value 공란 비워두면 주의 메일 옴! 주의)

그래서 내가 선택한 방법은,

1. 광각카메라를 인식하여 광각카메라인 경우 카메라 입력에 추가하여 예외처리하기

구현했지만 카메라를 제대로 인식하지 못해 보류 (코드엔 넣어놓음)

        // 광각 카메라 찾기
        guard let wideAngleCamera = AVCaptureDevice.DiscoverySession(
            deviceTypes: [.builtInWideAngleCamera],
            mediaType: .video,
            position: .back).devices.first else {
            fatalError("광각 카메라를 찾을 수 없습니다.")
        }
        captureDevice = wideAngleCamera

2. auto-focusing 구현

자동으로 초점을 맞추도록 구현하려고 했으나 어플에 해당 코드를 집어넣으면 코드에 오류 발생, 문제를 해결하지 못해 해당 방법은 기각함

3. touch-focusing 구현

• 터치하면 focusing 되도록 구현했고 작동은 하지만 문제를 해결할만큼 확실히 작동하는 것 같지는 않음

1. 터치, 포커스 구현 코드

// 터치 제스처 설정
private func setupTapGestureRecognizer() {
    let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleTapToFocus(_:)))
    view.addGestureRecognizer(tapGestureRecognizer)
}

@objc private func handleTapToFocus(_ tap: UITapGestureRecognizer) {
    let location = tap.location(in: view)
    let devicePoint = previewLayer.captureDevicePointConverted(fromLayerPoint: location)

    guard let device = captureDevice else { return }

    do {
        try device.lockForConfiguration()

        if device.isFocusPointOfInterestSupported {
            device.focusPointOfInterest = devicePoint
            device.focusMode = .autoFocus
        }

        if device.isExposurePointOfInterestSupported {
            device.exposurePointOfInterest = devicePoint
            device.exposureMode = .autoExpose
        }

        device.unlockForConfiguration()

        // 포커스 애니메이션
        focusView.center = location
        focusView.isHidden = false
        UIView.animate(withDuration: 0.3, animations: {
            self.focusView.transform = CGAffineTransform(scaleX: 1.25, y: 1.25)
        }) { _ in
            UIView.animate(withDuration: 0.3) {
                self.focusView.transform = CGAffineTransform.identity
            }
        }

    } catch {
        print("포커스 설정 중 오류 발생: \\(error.localizedDescription)")
    }
}

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    // 카메라 포커스 모드 설정
    if let videoCaptureDevice = captureDevice {
        do {
            try videoCaptureDevice.lockForConfiguration()
            if videoCaptureDevice.isFocusModeSupported(.continuousAutoFocus) {
                videoCaptureDevice.focusMode = .continuousAutoFocus
            }
            if videoCaptureDevice.isAutoFocusRangeRestrictionSupported {
                videoCaptureDevice.autoFocusRangeRestriction = .near
            }
            videoCaptureDevice.unlockForConfiguration()
        } catch {
            print("카메라 포커스 설정에 실패했습니다.")
        }
    }
}

2. viewDidLoad 내에서 터치제스처 인식하는 함수 불러오기

setupTapGestureRecognizer() // 터치 제스처 설정 추가

3. focus animation

// 포커스 뷰 선언
private var focusView: UIView!

4. viewDidLoad 내 설정

// 포커스 애니메이션 뷰 설정
focusView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
focusView.layer.borderWidth = 1.0
focusView.layer.borderColor = UIColor.yellow.cgColor
focusView.backgroundColor = UIColor.clear
focusView.isHidden = true
view.addSubview(focusView)

4. zoom 기능 구현

차라리 멀리서 초점을 맞춰서 확대하자!

1. pinch 기능(swift내부에 o), zoomFactor 사용

• 핀치 제스처 설정

private func setupPinchGestureRecognizer() {
       let pinchGestureRecognizer = UIPinchGestureRecognizer(target: self, action: #selector(handlePinchCamera(_:)))
       view.addGestureRecognizer(pinchGestureRecognizer)

• 핀치 제스처 핸들러

@objc private func handlePinchCamera(_ pinch: UIPinchGestureRecognizer) {
       guard let device = captureDevice else { return }

       let minZoomFactor: CGFloat = 1.0
       let maxZoomFactor: CGFloat = device.maxAvailableVideoZoomFactor

       switch pinch.state {
       case .began:
           lastZoomFactor = device.videoZoomFactor
       case .changed:
           var newZoomFactor = lastZoomFactor * pinch.scale
           newZoomFactor = min(max(newZoomFactor, minZoomFactor), maxZoomFactor)
           do {
               try device.lockForConfiguration()
               device.videoZoomFactor = newZoomFactor
               device.unlockForConfiguration()
           } catch {
               print("줌 조절 중 오류 발생: \\(error.localizedDescription)")
           }
       case .ended, .cancelled:
           pinch.scale = 1.0
       default:
           break
       }
   }

Finally

zoom 기능 구현 후 touch-focusing 보완해서 두 기능을 넣어 어플 배포 완료

먼저 연관관계 매핑에 대해 알아보도록 하자.

연관관계 매핑이란?

연관관계 매핑이란, 데이터베이스에서 테이블 간의 관계를 정의하는 것이다. 즉, 객체(Entity) 간의 관계를 설정해 데이터를 효율적으로 저장하고 조회할 수 있도록 하는 과정이다.

연관관계 매핑을 설명하기 전 기본 개념인 PK와 FK에 대해 설명하도록 하겠다.

📌 PK(기본 키)와 FK(외래 키)

PK (Primary Key, 기본 키)

PK(기본 키)란 테이블에서 각 행(Row)을 유일하게 식별할 수 있는 값이다. 즉, 각 행을 구별하는 "주인공"이나 "대표주자" 역할을 한다고 생각하면 된다.

PK의 특징

• 유일함(Unique) : 한 테이블 내에서 같은 값이 중복될 수 없다.
• NULL이 될 수 없음 : 반드시 값이 존재해야 함
• 한 테이블에 하나만 존재함 (복합키 제외)

  Spring Boot JPA에서 PK 설정

  import jakarta.persistence.*;
  

@Entity public class User { @Id // PK 설정 @GeneratedValue(strategy = GenerationType.IDENTITY) // 자동 증가 (Auto Increment) private Long id;

private String name;
private String email;

}

- **@Id**를 사용하여 id 필드를 기본 키(PK)로 설정한다.
- **@GeneratedValue(strategy = GenerationType.IDENTITY)** 
 : 키 값이 자동 증가하도록 설정한다.


>  ### FK (Foreign Key, 외래 키)
**FK(외래 키)**란 다른 테이블의 PK를 참조하는 키이다.
즉, 두 테이블을 연결해주는 "**다리**" 역할을 한다고 보면 된다.

#### FK의 특징
- 한 테이블이 다른 테이블을 참조할 때 사용한다.
- PK의 값을 가져와서 사용한다.
- 연관된 데이터를 무결성 있게 관리할 수 있다.

####  Spring Boot JPA에서 FK 설정

import jakarta.persistence.*;

@Entity public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;

@ManyToOne // 다대일 관계 설정
@JoinColumn(name = "user_id") // FK 컬럼명 지정
private User user;

private String product;

}

- @JoinColumn(name = "user_id")
: FK 컬럼명을 user_id로 지정하는 것이다.

**@ManyToOne**이라는 어노테이션이 바로 연관관계 매핑 중 하나이다.

> ##  연관관계 매핑의 종류
#### 1:1 (일대일)    
- 하나의 엔티티가 다른 엔티티와 1:1로 연결하는 것이다
- 예) 사용자(User) - 프로필(Profile)
#### 1:N (일대다)    
- 하나의 엔티티가 여러 엔티티와 연결되는 것이다.
- 예) 사용자(User) - 주문(Order)
#### N:M (다대다)    
- 여러 엔티티가 여러 엔티티와 연결되는 것이다.
- 예) 주문(Order) - 장바구니(Cart)

## 📍 1:1 (일대일) 관계
#### : 한 엔티티가 다른 엔티티와 1개의 관계만 가짐

#### User.java

@Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name;

@OneToOne // 일대일 관계 설정
@JoinColumn(name = "profile_id") // FK 설정
private Profile profile;

}

- User 엔티티는 id(PK), name, profile(FK)를 멤버로 가진다.
#### Profile.java

@Entity public class Profile { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String bio; }

- Profile 엔티티는 id(PK), bio를 멤버로 가진다.



## 📍 1:N (일대다) 관계
#### User.java

@Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name;

@OneToMany(mappedBy = "user") // 일대다 관계 설정
private List<Order> orders = new ArrayList<>();

}

- User엔티티는 id(PK), name, orders를 멤버로 가진다.
#### Order.java

@Entity public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String product;

@ManyToOne
@JoinColumn(name = "user_id") // FK 설정
private User user;

}

- Order 엔티티는 id(PK), product, user(FK)를 멤버로 가진다.

여기서 FK는 **@ManyToOne**인 객체가 갖는 것이다.
**mappedBy**는 Order 테이블의 user 필드와 매핑한다는 뜻이다.

## 📍 N:M (다대다) 관계
다대다 관계에서는 중간 테이블을 생성하여 관리한다.
Student_Course라는 중간테이블에 id (PK), student_id(FK), course_id(FK) 이 세 멤버가 추가된다.
#### Student.java

@Entity public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name;

@ManyToMany
@JoinTable(
    name = "student_course",
    joinColumns = @JoinColumn(name = "student_id"),
    inverseJoinColumns = @JoinColumn(name = "course_id")
) // 중간 테이블 설정
private List<Course> courses = new ArrayList<>();

}

#### Course.java

@Entity public class Course { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String title;

@ManyToMany(mappedBy = "courses")
private List<Student> students = new ArrayList<>();

}

그러나 실무에서는 ManyToMany를 많이 사용하지 않는다.
추가적인 데이터 저장 불가능, 성능 문제, 데이터 변경 어려움 등의 이유라는데 일단 알아두기!

#### 다음으로, **영속성 전이**와 **조회 방식**에 대해 알아보자
> ### Cascade (영속성 전이)
####  부모 엔티티의 변경이 자식 엔티티에도 영향을 미치도록 하는 설정

@OneToMany(mappedBy = "user", cascade = CascadeType.ALL) private List orders = new ArrayList<>();

- **CascadeType.ALL **
: User가 삭제되면 Order도 삭제됨
- **CascadeType.PERSIST **
: User 저장 시 Order도 자동 저장
- **CascadeType.REMOVE **
: User 삭제 시 Order도 삭제

> ### FetchType (지연 로딩 vs 즉시 로딩)
#### 연관된 엔티티를 조회할 때, 데이터를 즉시 가져올지(LAZY) 또는 필요할 때 가져올지(EAGER) 설정

@ManyToOne(fetch = FetchType.LAZY) private User user;

```

• FetchType.LAZY : 필요할 때 데이터를 가져옴 (성능 최적화)
• *FetchType.EAGER * : 항상 데이터를 즉시 가져옴 (JOIN 실행됨, 성능 부담)

기본 설정

@OneToOne, @ManyToOne → 기본값 EAGER @OneToMany, @ManyToMany → 기본값 LAZY

Spring MVC의 Controller

• Spring MVC에서 Controller(컨트롤러)는 클라이언트의 요청을 받아 비즈니스 로직(Service)과 View(예를 들면, Thymeleaf)를 연결하는 역할을 한다.
• Controller는 사용자 요청을 처리하고, 데이터를 Model에 담아 View로 전달하는 역할을 한다.

Controller의 역할

• 클라이언트의 HTTP 요청을 처리한다.
• Service를 호출하여 비즈니스 로직을 수행한다.
• Model을 사용하여 View로 데이터 전달
• REST API를 제공하는 경우 JSON 응답 반환 가능하다.

Controller는 클라이언트(View 또는 API 요청)와 Service 간의 다리 역할을 수행한다고 생각하면 된다.

📌 Spring MVC의 데이터 흐름 정리

클라이언트 → Controller → Service → Repository → Entity → DB → Entity → Repository → Service → Controller → Model → View(Thymeleaf) → 클라이언트 응답

📍 참고로, 여기에 있는 Model은 MVC 패턴의 Model과 같은 것이 아니다.

• 이 Model은 Spring MVC에서의 Model 객체 (org.springframework.ui.Model)인데,
  Spring MVC에서 Model 객체는 Controller가 데이터를 View로 전달하는 역할을 한다. 즉, 여기서의 Model 객체는 단순히 View에서 사용할 데이터를 담는 컨테이너일 뿐이다!

이제, 기본적인 예제를 살펴보도록 하자.

1. Controller 기본 예제

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "Spring MVC 프로젝트에 오신 것을 환영합니다!");
        return "home"; // home.html로 이동
    }
}

• @Controller를 사용하여 Spring MVC 컨트롤러로 등록
• @GetMapping("/") → 사용자가 / 경로로 GET 요청을 하면 home.html을 반환
• Model을 사용하여 View에 데이터를 전달

2. Controller에서 Service 연동 예제

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import java.util.List;

@Controller
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/users")
    public String getUsers(Model model) {
        List<UserDTO> users = userService.getAllUsers();
        model.addAttribute("users", users);
        return "user-list"; // user-list.html로 이동
    }
}

• Service를 호출하여 데이터 가져오기
• Model을 사용하여 View에 데이터를 전달

3. 요청 파라미터 처리

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class SearchController {

    @GetMapping("/search")
    public String search(@RequestParam String keyword, Model model) {
        model.addAttribute("keyword", keyword);
        return "search-results";
    }
}

• view에서 이용 예시

  <p>검색어: <span th:text="${keyword}"></span></p>
  

어노테이션이 굉장히 많은데, 어노테이션을 이해하면 Controller를 이해하기 더 쉬울 것이다.
다음으로 Controller에서 주로 사용하는 어노테이션에 대해 알아보자.
 ##  📍 Controller에서 사용하는 주요 어노테이션
>  ### 1. @Controller vs @RestController
Controller를 정의할 때 가장 많이 사용하는 어노테이션이다.

### @Controller
-  Spring MVC 컨트롤러를 정의하는 어노테이션이다.
- 반환 타입은 **View(Thymeleaf, JSP)**이다.
- Thymeleaf와 같은 View 템플릿을 사용하여 **HTML을 반환**하는 경우 사용한다.

@Controller public class HomeController { @GetMapping("/") public String home(Model model) { model.addAttribute("message", "Spring MVC 프로젝트!"); return "home"; // home.html 템플릿 반환 } }

### @RestController    
- REST API 컨트롤러를 정의하는 어노테이션이다.
- REST API를 개발할 때 사용하며, JSON 데이터를 반환할 때 사용한다.

@RestController @RequestMapping("/api") public class ApiController { @GetMapping("/message") public String getMessage() { return "Hello, this is a REST API response!"; } }

#### 📍 만약 Controller에서 JSON을 반환하고싶다면, **@ResponseBody** 사용하기

@Controller @ResponseBody public class ExampleController { @GetMapping("/json") public String getJson() { return "{"message": "Hello, JSON!"}"; } }

- @ResponseBody(밑에서 설명)를 사용하면** @RestController와 동일한 효과**를 볼 수 있다.
- 참고로 **@RestController**는 **@Controller + @ResponseBody**의 조합이다.

> ### 2. @RequestMapping vs @GetMapping vs @PostMapping
Spring에서 HTTP 요청을 처리하기 위해 사용되는 매핑 어노테이션이다.

### @RequestMapping    
: 공통 URL 패턴, 즉 모든 html 메서드(GET, POST, PUT 등)을 매핑하는 어노테이션이다.

@Controller @RequestMapping("/users") public class UserController { @RequestMapping("/list") public String getUserList() { return "user-list"; // user-list.html 반환 } }

### @GetMapping    
: HTTP GET 요청을 처리한다.
### @PostMapping
: HTTP POST 요청을 처리한다.

@Controller @RequestMapping("/users") public class UserController { @GetMapping("/list") public String getUsers() { return "user-list"; // GET 요청 } @PostMapping("/add") public String addUser() { return "redirect:/users/list"; // POST 요청 } }

- @RequestMapping을 사용할 수도 있지만, @GetMapping 같은 세부적인 매핑을 권장한다고 한다!

> ### 3. @RequestParam vs @PathVariable
클라이언트가 보낸 데이터를 받을 때 사용하는 어노테이션이다.

### @RequestParam    
- 쿼리 스트링 파라미터를 받는다.
- ?key=value 형태

@Controller @RequestMapping("/search") public class SearchController { @GetMapping public String search(@RequestParam String keyword, Model model) { model.addAttribute("keyword", keyword); return "search-results"; // search-results.html 반환 } }

- 클라이언트 요청은 http ://localhost:8080/search?keyword=Spring의 형태이며 @RequestParam을 통해 keyword 값을 가져온다.
### @PathVariable    
- URL 경로 변수를 받는다.
- /users/{id} 형태

@RestController @RequestMapping("/api/users") public class UserRestController { @GetMapping("/{id}") public String getUserById(@PathVariable Long id) { return "User ID: " + id; } }

요청은 http: //localhost:8080/api/users/10의 형태이며 @PathVariable을 사용하여 id=10 값을 가져온다.

> ### 4. @ModelAttribute vs @RequestBody
마지막으로, 사용자로부터 폼 데이터를 받을 때 사용하는 어노테이션이다.

### @ModelAttribute    
: 폼 데이터를 객체로 변환한다. (Form (HTML)형식)

@Controller @RequestMapping("/users") public class UserController {

@PostMapping("/form")
public String submitUserForm(@ModelAttribute UserDTO userDTO) {
    System.out.println("Name: " + userDTO.getName());
    System.out.println("Email: " + userDTO.getEmail());
    return "redirect:/users";
}

}

- 사용예시

<form action="/users/form" method="post">
    <input type="text" name="name" placeholder="이름" />
    <input type="email" name="email" placeholder="이메일" />
    <button type="submit">제출</button>
</form>

### @RequestBody
: JSON 데이터를 객체로 변환한다.

@RestController @RequestMapping("/api/users") public class UserRestController {

@PostMapping
public String createUser(@RequestBody UserDTO userDTO) {
    return "User created: " + userDTO.getName();
}

}

- 사용 예시

{ "name": "홍길동", "email": "hong@example.com" }

이렇게 해야 유지보수가 쉽고 Controller, Model, View를 독립적으로 개발할 수 있어 확장성이 높기 때문인데, 일단 MVC가 무엇인지 알아야 효율적으로 개발을 할 수 있으니 MVC가 무엇인지 알아보도록 하자!

📌 MVC(Model-View-Controller) 패턴이란?

소프트웨어 아키텍처 패턴 중 하나로, 애플리케이션의 역할을 Model-View-Controller 3가지로 분리하여 유지보수와 확장성을 높이는 구조

Spring Boot에서 기본적으로 MVC패턴을 사용해서 웹 애플리케이션을 개발한다.

Spring MVC의 동작 과정

1. 사용자가 요청(URL 요청)
2. DispatcherServlet(프론트 컨트롤러)가 요청을 가로챔
3. 요청을 적절한 Controller에게 전달
4. Controller는 요청을 처리하고, 필요한 데이터를** Service**를 통해 조회
5. Service는 데이터베이스와 연동되는 Repository를 호출
6. Repository가 MySQL 등의 DB와 연결하여 데이터 조회 및 처리
7. 조회한 데이터를 Model에 담아서 View(Thymeleaf)로 전달
8. Thymeleaf 템플릿 엔진이 데이터를 화면에 렌더링
9. 완성된 HTML이 사용자에게 응답으로 반환됨

아직 잘 이해가 되지 않을테니 밑에서 더 알아보도록 하자

📍 MVC 패턴의 개념

먼저 MVC란, 애플리케이션을 Model(모델) - View(뷰) - Controller(컨트롤러) 3가지 역할로 나누어 개발하는 구조를 말한다.

가장 먼저 Model에 대해 알아보자.

Model (모델)

• 데이터를 처리하는 역할로, 데이터베이스와 연결되어 데이터를 저장하고 가공한다.
• MVC 패턴에서 Model은 애플리케이션의 데이터를 다루는 모든 로직을 포함하는데,
• Entity*와 DTO, Service, Repository가 포함된다.

1. Entity

개념

• 데이터베이스의 테이블과 1:1 매핑되는 클래스이며 @Entity 어노테이션을 사용하여 정의한다.
• 데이터 저장, 조회, 수정, 삭제 등을 수행하는 객체 자체이며 일반적으로 Service나 Repository에서 사용된다.

쉽게 말해 데이터베이스에 테이블, 즉 데이터가 있을 때, 우리는 작성한 클래스 위에** @Entity**라는 어노테이션을 붙여서_ 이 클래스가 엔티티이고 해당 테이블과 매핑된다!_ 라고 선언해주는 것이다.

Entity의 특징

• DB 테이블과 매핑되어 직접적인 데이터 저장소 역할을 한다.
• @Entity, @Table, @Id, @Column 등의 JPA 어노테이션을 사용한다.

비즈니스 로직이 포함되지 않고, 데이터 자체를 표현하는 것이 목적이다!

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;
    private String password;
}

예시 코드를 보면 @Entity 어노테이션으로 선언해준 것을 알 수 있다.

2. Repository

개념

• Entity를 이용해 데이터베이스와 직접 소통하는 계층이다.
• 데이터를 저장, 조회, 수정, 삭제(CRUD)하는 역할이며 Spring Data JPA를 사용하면 SQL을 직접 작성하지 않아도 자동으로 처리된다.

Repository의 특징

• JpaRepository<Entity, ID 타입>을 상속하면 기본적인 *CRUD 기능 *제공
• DB와의 직접적인 연동을 담당하며, Entity를 다룬다.

즉, Respository는 JPA를 사용하여 DB에 접근, 직접 상호작용하는 계층이며 Entity를 다루게 된다.

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    // JpaRepository<User, Long>을 상속하면 기본 CRUD 메서드를 자동 생성
}

기본으로 제공되는 메서드는 다음과 같다.

📍 기본 제공 메서드

save(User user) : 사용자 저장

findById(Long id) : 특정 사용자 조회

findAll() : 모든 사용자 조회

deleteById(Long id) : 특정 사용자 삭제

count() : 총 사용자 수 반환

3. Service란?

개념

• 비즈니스 로직을 처리하는 계층이다.
• Repository를 통해 데이터베이스에서 값을 조회하거나, 가공하여 Controller에 전달한다.
• 여러 Repository를 조합하여 복잡한 로직을 수행 가능

Service의 역할

• Controller에서 받은 요청을 처리하고 Repository를 호출하여 DB와 연동한다.
• 데이터를 가공하여 DTO로 변환 후 Controller에 반환한다.

즉, Controller와 Repository의 중간 통로 역할을 한다고 생각하면 된다.

import org.springframework.stereotype.Service;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // 모든 사용자 조회 (Entity → DTO 변환)
    public List<UserDTO> getAllUsers() {
        return userRepository.findAll()
                .stream()
                .map(user -> new UserDTO(user.getName(), user.getEmail()))
                .collect(Collectors.toList());
    }

    // 사용자 저장 (DTO → Entity 변환)
    public void saveUser(UserDTO userDTO) {
        User user = new User();
        user.setName(userDTO.getName());
        user.setEmail(userDTO.getEmail());
        user.setPassword("defaultPassword"); // 실제 환경에서는 암호화 필요
        userRepository.save(user);
    }
}

• getAllUsers() → Entity를 DTO로 변환 후 반환
• saveUser() → DTO를 Entity로 변환 후 저장
• Controller는 Service의 메서드를 호출하여 데이터를 처리한다.

4. DTO란?

개념

• 계층 간 데이터 전송을 위해 사용하는 객체이다.
• Entity와 달리 DB와 직접적인 연동이 없고, 필요한 데이터만 포함한다.
• Entity의 민감한 정보를 숨기거나, 가공된 데이터를 전송하는 역할이다.

DTO의 역할

• Controller ↔ Service ↔ Repository 간의 데이터 전송
• Entity의 불필요한 데이터를 숨기고, 필요한 데이터만 포함
• 보안 강화 (비밀번호 같은 민감한 정보를 제외 가능)
• API 응답 시 DTO 사용으로 유연한 데이터 반환 가능

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@NoArgsConstructor
public class UserDTO {
    private String name;
    private String email;

    public UserDTO(String name, String email) {
        this.name = name;
        this.email = email;
    }
}

Entity 중 민감하지 않은 정보만 뽑아 정보를 전송하는 클래스라고 생각하면 된다.

• Entity와 다르게** password 필드가 없음**
• View에서 사용할 데이터만 포함
• Service에서 Entity → DTO 변환 후 반환

📌 JPA (Java Persistence API)란?

Java 애플리케이션에서 데이터베이스와 상호작용하는 표준 인터페이스

쉽게 말해, SQL 없이 객체만으로 데이터베이스를 조작할 수 있도록 도와주는 기술이다!

Java 객체를 데이터베이스 테이블과 매핑(Mapping)하는 기술

• SQL을 직접 작성하지 않아도 되기 때문에 객체만 다루면 된다.
• Hibernate 같은 구현체가 JPA의 기능을 실제로 제공하며 자동으로 SQL을 생성하고 실행한다. 즉 내 손으로 SQL문을 작성할 필요가 없다
• 데이터베이스가 바뀌어도 코드 수정이 거의 없다.

📌 JPA vs JDBC

** SQL 직접 작성 여부 | 객체 매핑 | 학습 난이도 | 유지보수 ** JDBC - 직접 작성해야 함 | 없음 | 쉬움 | 어려움 JPA - 자동 생성 (필요 시 직접 작성 가능) | 완전 지원 (ORM) | 어려움 | 쉬움 ➡ JDBC는 SQL을 직접 작성해야 하지만, JPA는 SQL을 자동으로 생성하고 실행함!

이제 JPA의 동작 방식에 대해 알아보자.

1. Entity란?

JPA에서 데이터베이스의 테이블과 매핑되는 클래스이다.

이렇게 말하면 잘 감이 안올테니, 하나의 객체라고 생각하면 된다. JPA에서는 database가 아닌 entity, 즉 객체 중심의 개발을 하는 것이다. 따라서 객체지향 프로그래밍 을 한다는 말이다! 객체지향 프로그래밍과 절차지향 프로그래밍에 대한 내용은 다음 포스팅에 ....

@Entity // JPA가 관리하는 엔티티임을 표시
@Table(name = "member") // 테이블명 설정 (생략 가능)
public class Member {
    @Id // PK 설정
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 자동 증가 (AUTO_INCREMENT)
    private Long id;
    @Column(nullable = false, length = 100) // DB 컬럼 설정
    private String name;
    private int age;
}

데이터베이스에 테이블을 만들고 이에 대응하는 클래스를 만들어 클래스 위에** @Entity 어노테이션** 을 붙이면 이 클래스 자체가 엔티티가 되는 것이다.

• @Entity: 해당 클래스를 JPA에서 관리하는 엔티티로 지정
• @Id: 기본 키(PK) 설정 PK와 FK, 연관관계 매핑에 대해서는 추후 포스팅에서 다루겠다.
• @GeneratedValue(strategy = GenerationType.IDENTITY): 자동 증가(AUTO_INCREMENT)
• ** @Column**: 컬럼 설정 (nullable, length 등)

2. 엔티티 매니저 / 엔티티 매니저 팩토리

엔티티 매니터 팩토리란?

• 엔티티 매니저 인스턴스를 관리하는 주체이다. 사용자로부터 요청이 오면 여기에서 앤티티 매니저를 생성한다.

그렇다면, 엔티티 매니저란 무엇일까?

엔티티 매니저란?

• 엔티티 매니저란 내부적으로 영속성 컨텍스트에 접근해 엔티티에 대한 데이터베이스 작업을 제공하는 것을 말한다.

다음은 영속성 컨텍스트에 대해 알아보자.

3. 영속성 컨텍스트란?

JPA가 엔티티를 관리하는 공간, 즉 엔티티를 영구 저장하는 환경이다.

엔티티를 데이터베이스에서 가져오거나 변경 사항을 감지하고 반영하는 역할을 한다.

• persist() → 엔티티 저장
• find() → 엔티티 조회 (1차 캐시 사용)
• remove() → 엔티티 삭제
• commit() → 변경 사항을 DB에 반영

예시 코드를 보면, SQL을 직접 작성하지 않아도 persist()를 호출하면 자동으로 INSERT 문이 실행된다는 것을 볼 수 있다.

EntityManager em = emf.createEntityManager();
em.getTransaction().begin(); // 트랜잭션 시작

Member member = new Member();
member.setName("홍길동");
member.setAge(25);

em.persist(member); // INSERT 자동 실행
em.getTransaction().commit(); // 트랜잭션 커밋

다음으로 spring data jpa에 대해 알아보도록 하자.

Spring Data JPA란?

JPA를 더 쉽게 사용할 수 있도록 도와주는 라이브러리이다

기본적인 CRUD 기능을 자동으로 제공한다.

public interface MemberRepository extends JpaRepository<Member, Long> {
    List<Member> findByName(String name); // 메서드 이름만으로 쿼리 자동 생성
}

SQL을 직접 작성하지 않아도 findByName()을 호출하면 자동으로 SELECT * FROM member WHERE name = ? 실행된다.

📌 정리

• JPA는 SQL을 자동으로 생성하고 실행하는 기술
• 객체(Entity) 중심으로 개발할 수 있어 유지보수가 쉬움
• Spring Data JPA를 활용하면 더 간단하게 CRUD 구현 가능

JPA를 사용하면 SQL을 직접 작성하지 않고도 객체 지향적인 방식으로 데이터베이스를 조작할 수 있어 훨씬 편리하고 유지보수도 쉬워진다!

Lombok 라이브러리

Getter/Setter, ToString과 같은 반복적인 자바 코드를 컴파일할 때 자동으로 생성해주는 라이브러리인 "Lombok 라이브러리"를 설치해주면 된다.

IntelliJ - 설정 - 플러그인에 들어가서 lombok을 검색해서 설치해준다.

그리고 다시 설정으로 들어가서

[빌드,실행,배포] - [컴파일러] - [어노테이션 프로세서]에 들어가서 "어노테이션 처리 활성화"에 체크되어있는지 확인한다. (안되어있으면 체크하기)

Dependecy 추가

pom.xml에

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

이 코드를 추가해주면 끝!

• 오류가 뜰 때 우클릭 -> Maven -> 프로젝트 다시 로드 하면 되는 경우도 있으니 참고!

Spring Boot Project 생성

https://start.spring.io/ 에 접속한 후 옵션들을 선택한다.

자바 23버전이기 때문에 (jdk 설치하는 법은 이전 포스팅 참고!) Java 23으로 설정해주고 빌드 툴은 메이븐으로 설정한다. 또한 의존성 추가를 위해 우측 상단의 'ADD DEPENDENCIES'버튼을 눌러 'Spring Web'을 선택해준다.

• 의존성을 추가한다는 것은 다른 라이브러리를 사용하기 위해 추가하는 것이라고 생각하면 됨!

원하는 이름으로 설정해주고 'GENERATE' 버튼을 누르면 아티팩트 이름과 같은 파일이 다운로드 된다-! 원하는 워크스페이스에서 압축을 풀어준다. 그리고 이전에 설치했던 인텔리제이 실행하여 '열기'를 눌러 압축 풀었던 파일을 열어준다. sdk까지 23버전으로 설정해주면 완료!

• main/java패키지 아래에 자바 소스코드를 작성
• main/resources 디렉토리 아래 HTML, CSS, JS 등 정적 리소스 저장
• 템플릿 엔진인 thymeleaf는 기본적 뷰를 src/main/resources/templates/에서 찾는다. 해당 디렉토리 아래 HTML 파일을 작성하고 Controller Class 에서 반환한 뷰와 동일한 이름의 html 파일을 찾아 웹 드라우저에 띄운다.
• src/test/java 패키지 아래 테스트 코드 작성

Maven

Maven - 프로젝트의 빌드를 자동화해주는 빌트 둘이다. 개발 과정 중 많은 라이브러리가 필요한데 메이븐이 알아서 네트워크를 통해 다운로드하고 경로 지정까지 해준다!

메이븐 설정에 들어가면 이러한 창이 뜨고 로컬 저장소 확인이 가능하다. 여러 프로젝트를 동시 진행할 때 Local repository를 프로젝트별로 다른 폴더를 지정하는 것 추천!

설정파일

설정파일이란 스트링 부트 어플리케이션 실행 시 사용하는 여러가지 설정 값들을 정의하는 파일 src/main/resources 폴더 아래 자동생성된다.

여기까지 하면 기본적인 설정 완료~

JDK 설치

첫 번째 스텝은 JDK를 설치해주는 것!

먼저 Oracle 사이트에서 Java를 다운받는다. https://www.oracle.com/kr/java/technologies/downloads/#java23 두 번째에 있는 ARM64 DMG Installer를 다운받으면 된다.

계속 설치를 진행해주면 완료!

다음은 터미널에서 정상적으로 설치가 되었는지 확인하면 된다.

• command+space를 치면 검색창이 뜨는데 여기에서 터미널 검색 후에 열면 된다.

1. java --version (설치된 버전 확인)
2. which java (설치된 경로 확인)
3. cd /usr/bin (해당 경로로 이동)
4. ls -lrt java (java가 포함된 모든 파일 보기)

성공적으로 설치가 된 것을 볼 수 있다!

1. csr 만들기

키체인 접근 - 인증서 지원 - 인증 기관에서 인증서 요청... 이메일, 이름 작성 후 디스크에 저장됨 체크하고 계속 -> csr 생성 완료!

2. 인증서 갱신

a) Apple Developer 접속

https://developer.apple.com/

b) Account - 인증서 - 왼쪽 바 중 identifiers - 인증서 갱신할 앱 선택

c) Push Notifications - Edit / configure

Production SSL Certificate - Create Certificate

아까 만들어두었던 csr 등록!

d) 인증서 파일을 다운로드 후 더블클릭

-> 키체인에 등록 완료

e) 키체인에 등록된 인증서 하위 항목에 있는 key 마우스 오른쪽 클릭 - 내보내기

-> 인증서 생성 완료!

3. 인증서 교체

• 서버에서 새로운 인증서가 등록된 것 확인 후 만료된 인증서는 revoke => 새로운 인증서로 교체하면 끝