😀
fistkim TECH BLOG
  • Intro
  • 강의
    • Reactive Programming in Modern Java using Project Reactor
      • Reactor execution model 1
      • Reactor execution model 2
      • Reactor execution model 3 - parallelism
      • Reactor execution model 4 - overview
      • Transform
      • Combine
      • Side Effect Methods
      • Exception/Error handling
      • retry, retryWhen, repeat
      • BackPressure
      • Cold & Hot Streams
    • NEXTSTEP 클린코드 with java 9기
      • 정리노트
    • NEXTSTEP DDD 세레나데 2기
      • CH01 도메인 주도 설계 이해
      • CH02 크게 소리 내어 모델링 하기
      • CH03 도메인 주도 설계 기본 요소
      • CH04 도메인 주도 설계 아키텍처
      • CH05 도메인 이벤트
    • NEXTSTEP 인프라 공방 1기
      • 망 분리하기
      • 통신 확인하기
      • 도커 컨테이너 이해하기
      • [미션 1] 서비스 구성하기 실습
      • [미션 2] 서비스 배포하기 실습
      • 서버 진단하기
      • 어플리케이션 진단하기
      • [미션 3] 서비스 운영하기
      • 웹 성능 진단하기
      • 부하 테스트
      • k6
      • [미션 4] 성능 테스트
      • 리버스 프록시 개선하기
      • 캐싱 활용하기
      • [미션 5] 화면 응답 개선하기
      • Redis Annotation 및 설정
      • 인덱스 이해하기 & DB 튜닝
      • [미션 6-1] 조회 성능 개선하기
      • [미션 6-2] DB 이중화 적용
    • NEXTSTEP 만들면서 배우는 Spring 3기
      • CH01 올바른 방향 바라보기
      • CH02 HTTP 이해 - 웹 서버 구현
        • HTTP 파싱
        • HTTP 웹 서버 구현
      • CH03 MVC - @MVC 프레임워크 구현
        • Servlet 다시 짚기
        • Cookie, Session 다시 짚기
        • MVC 프레임워크 구현
      • CH04 나만의 라이브러리 구현
      • CH05 DI - DI 프레임워크 구현
      • CH06 Aspect OP
    • 스프링 시큐리티
      • 스프링 시큐리티 아키텍처
      • WebAsyncManagerIntegrationFilter
      • SecurityContextPersistenceFilter
      • HeaderWriterFilter
      • CsrfFilter
      • (+) 스프링 시큐리티 + JWT
      • (+) 마치며
    • 더 자바, 코드를 조작하는 다양한 방법
      • CH01 JVM 이해하기
      • (+) 클래스 로더 이해하기
      • CH02 바이트 코드 분석 및 조작
      • (+) jacoco
      • CH03 리플렉션
      • CH04 다이나믹 프록시
      • CH05 애노테이션 프로세서
    • 더 자바, 애플리케이션을 테스트하는 다양한 방법
      • CH01 JUnit 5
      • CH02 Mockito
      • (+) Spy vs Mock
      • CH03 도커와 테스트
      • CH04 성능 테스트
      • (+) VisualVM
      • (+) 테스트 자동화
      • CH05 운영 이슈 테스트
      • CH06 아키텍처 테스트
    • 모든 개발자를 위한 HTTP 웹 기본 지식
      • CH01 인터넷 네트워크
      • CH02 HTTP 기본
      • CH03 HTTP 메서드 속성
      • CH04 HTTP 메서드 활용
      • CH05 HTTP 상태코드
      • CH06 HTTP 헤더1 - 일반 헤더
      • CH07 HTTP 헤더2 - 캐시와 조건부 요청
      • (+) HTTPS 원리
    • 스프링 프레임워크 핵심 기술
      • CH01 IOC 컨테이너
      • CH02 AOP
      • (+) 스프링 의존성 관리
      • (+) 생성자 주입 장점
    • 코딩으로 학습하는 GoF의 디자인 패턴
      • 객체 생성
        • 싱글톤 패턴
        • 팩토리 메소드 패턴
        • 추상 팩토리 패턴
        • 빌더 패턴
        • 프로토타입 패턴
      • 구조
        • 어댑터 패턴
        • 브릿지 패턴
        • 컴포짓 패턴
      • 행동
        • (작성중)
    • 실전 Querydsl
      • CH01 프로젝트 환경구성
      • CH02 예제 도메인 모델
      • CH03 기본문법
      • CH04 중급 문법
      • CH05 실무활용 (스프링 데이터 JPA와 Querydsl)
      • CH06 스프링데이터JPA 가 제공하는 Querydsl 기능
      • (+) 별칭(alias)
      • (+) Slice 쿼리
    • 스프링 데이터 JPA
      • CH01 핵심개념이해 1
      • CH02 핵심개념이해 2
      • CH03 핵심개념이해 3
      • CH04 Spring Data Common
      • CH05 Spring Data JPA
    • 실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화
      • CH01 지연 로딩과 조회 성능 최적화
      • CH02 컬렉션 조회 최적화
      • CH03 전체 정리
    • 초보를 위한 쿠버네티스 안내서
      • CH01 쿠버네티스 시작하기
      • CH02 쿠버네티스 알아보기
      • CH03 쿠버네티스 실습 준비
      • CH04 쿠버네티스 기본 실습
    • Flutter Provider Essential
      • CH01 Introduction
      • CH02 Provider Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Bloc Essential
      • CH01 Introduction
      • CH02 Bloc Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Advanced Course - Clean Architecture With MVVM
      • CH01 Introduction
      • CH02 Clean Architecture 4 Layer
      • CH03 MVVM
      • CH04 Data Layer
      • (+) Data Layer - response to model
      • (+) Data Layer - Network
      • CH05 Domain Layer
      • CH06 Presentation Layer
      • CH07 Application Layer
      • (+) Application Layer - l10n
      • (+) Application Layer - DI
      • (+) Application Layer - environment
    • 자바 알고리즘 입문
      • CH01 문자열
      • CH02 Array(1, 2 차원 배열)
      • CH03 Two pointers, Sliding window[효율성: O(n^2)-->O(n)]
      • CH04 HashMap, TreeSet (해쉬, 정렬지원 Set)
      • CH05 Stack, Queue(자료구조)
      • CH06 Sorting and Searching(정렬, 이분검색과 결정알고리즘)
      • CH07 Recursive, Tree, Graph(DFS, BFS 기초)
      • CH08 DFS, BFS 활용
      • CH09 Greedy Algorithm
      • CH10 dynamic programming(동적계획법)
  • 도서
    • 만들면서 배우는 클린 아키텍처
      • 학습목표
      • CH01 계층형 아키텍처의 문제는 무엇일까?
      • CH02 의존성 역전하기
      • CH03 코드 구성하기
      • CH04 유스케이스 구현하기
      • CH05 웹 어댑터 구현하기
      • CH06 영속성 어댑터 구현하기
      • CH07 아키텍처 요소 테스트하기
      • CH08 경계 간 매핑하기
      • CH09 어플리케이션 조립하기
      • CH10 아키텍처 경계 강제하기
      • CH11 의식적으로 지름길 사용하기
      • CH12 아키텍처 스타일 결정하기
    • 클린 아키텍처
      • 들어가며
      • 1부 소개
        • 1장 설계와 아키텍처란?
        • 2장 두 가지 가치에 대한 이야기
      • 2부 벽돌부터 시작하기: 프로그래밍 패러다임
        • 3장 패러다임 개요
        • 4장 구조적 프로그래밍
        • 5장 객체 지향 프로그래밍
        • 6장 함수형 프로그래밍
      • 3부 설계 원칙
        • 7장 SRP: 단일 책임 원칙
        • 8장 OCP: 개방-폐쇄 원칙
        • 9장 LSP: 리스코프 치환 원칙
        • 10장 ISP: 인터페이스 분리 원칙
        • 11장 DIP: 의존성 역전 원칙
      • 4부 컴포넌트 원칙
        • 12장 컴포넌트
        • 13장 컴포넌트 응집도
        • 14장 컴포넌트 결합
      • 5부
        • 15장 아키텍처란?
    • 스프링 입문을 위한 자바 객체 지향의 원리와 이해
      • CH01 사람을 사랑한 기술
      • CH02 자바와 절차적/구조적 프로그래밍
      • CH03 자바와 객체 지향
      • (+) 자바 코드 실행에 따른 메모리 적재과정
      • CH04 자바가 확장한 객체 지향
      • CH05 객체 지향 설계 5 원칙 - SOLID
      • CH06 스프링이 사랑한 디자인 패턴
      • CH07 스프링 삼각형과 설정 정보
      • (부록) 람다(lambda)
    • 객체지향의 사실과 오해
      • CH01 협력하는 객체들의 공동체
      • CH02 이상한 나라의 객체
      • CH03 타입과 추상화
      • CH04 역할, 책임, 협력
      • CH05 책임과 메시지
      • CH06 객체 지도
      • CH07 함께 모으기
      • (+) 인터페이스 개념 바로잡기
    • 도메인 주도 개발 시작하기
      • CH01 도메인 모델 시작하기
      • CH02 아키텍처 개요
      • CH03 애그리거트
      • CH04 리포지터리와 모델 구현
      • CH05 스프링 데이터 JPA를 이용한 조회 기능
      • CH06 응용 서비스와 표현 영역
      • CH07 도메인 서비스
      • CH08 애그리거트 트랜잭션 관리
      • CH09 도메인 모델과 바운디드 컨텍스트
      • CH10 이벤트
      • CH11 CQRS
    • 자바 ORM 표준 JPA 프로그래밍
      • CH01 JPA 소개
      • CH02 JPA 시작
      • CH03 영속성 관리
      • CH04 엔티티 매핑
      • CH05 연관관계 매핑 기초
      • CH06 다양한 연관관계 매핑
      • CH07 고급 매핑
      • CH08 프록시와 연관관계 관리
      • CH09 값 타입
      • CH10 객체지향 쿼리 언어
      • CH11 웹 애플리케이션 제작
      • CH12 스프링 데이터 JPA
      • CH13 웹 애플리케이션과 영속성 관리
      • CH14 컬렉션과 부가 기능
      • CH15 고급 주제와 성능 최적화
      • CH16 트랜잭션과 락, 2차 캐시
    • 소프트웨어 세상을 여는 컴퓨터과학
      • CH01 컴퓨터 과학 소개
      • CH02 데이터 표현과 디지털 논리
    • 이펙티브 자바
      • 1 장 들어가기
      • 2장 객체 생성과 파괴
        • [01] 생성자 대신 정적 팩터리 메서드를 고려하라
        • [02] 생성자에 매개변수가 많다면 빌더를 고려하라
        • [03] private 생성자나 열거 타입으로 싱글턴임을 보증하라
        • [04] 인스턴스화를 막으려거든 private 생성자를 사용하라
        • [05] 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라
        • [06] 불필요한 객체 생성을 피하라
        • [07] 다 쓴 객체 참조를 해제하라
        • [08] finalizer 와 cleaner 사용을 피하라
        • [09] try-finally 보다는 try-with-resources 를 사용하라
      • 3장 모든 객체의 공통 메서드
        • [10] equals는 일반 규약을 지켜 재정의하라
        • [11] equals 를 재정의하려거든 hashCode도 재정의하라
        • [12] toString 을 항상 재정의하라
        • [13] clone 재정의는 주의해서 진행하라
        • [14] Comparable 을 구현할지 고려하라
      • 4장 클래스와 인터페이스
        • [15] 클래스와 멤버의 접근 권한을 최소화하라
  • 토픽
    • 서버 모니터링
      • CPU 사용량
      • 메모리 사용량
      • 스레드 풀
    • Spring Boot Monitoring
      • Spring actuator
      • Spring eureka
      • Prometheus
      • grafana
      • Spring actuator + Prometheus + grafana
    • JAVA 데일리 토픽
      • 메모리 누수(memory leak)
      • 객체 참조의 유형
      • 커스텀 스레드 풀
      • Mark And Compact
      • serialVersionUID 이해하기
      • 함수형 인터페이스
      • 메소드 참조
      • equals()와 hashCode()가 무엇이고 역할이 무엇인지
      • StringBuffer vs StringBuilder
      • String vs StringBuilder, StringBuffer
      • String interning
    • JAVA GC
    • 프로그래머스 문제 풀기
      • 해시
      • 스택/큐
      • 힙(Heap)
      • 정렬
      • 완전탐색
      • DFS/BFS
    • 데이터베이스 구성 및 작동 흐름
    • 데이터베이스 JOIN 원리
    • 객체지향생활체조 원칙
    • 상태(state), 상속(inheritance), 합성(composition) 의 상관관계
    • java enum은 메모리에 언제, 어떻게 할당되는가
    • Checked Exception vs UnChecked Exception
    • Reactive Streams 원리탐구 - 간단한 예제 직접 작성해보기
    • Flutter Basic
    • Flutter StatefulWidget 생명주기
    • Flutter 가 위젯을 그리는 원리
    • Flutter 클린 아키텍처
      • application layer
        • 패키지 구조 및 레이어 설명
        • environment
        • dependency injection
        • go_router
        • foreground & background
        • 다국어처리 (l10n, i18n)
        • Global 처리(시스템 점검, fore->back 등)
        • connection_manager
        • permission_manager
        • push_notification_manager
        • firebase 연동
      • data layer
        • 패키지 구조 및 레이어 설명
        • network
        • repository
      • domain layer
        • 패키지 구조 및 레이어 설명
      • presentation layer
        • 패키지 구조 및 레이어 설명
        • resources
    • 기술 관련 포스팅 읽기
  • 기타
    • 작업일지
      • 2023. 10
      • 2023. 09
      • 2023. 08
      • 2023. 07
      • 2023. 06
      • 2023. 05
      • 2023. 04
      • 2023. 03
      • 2023. 02
      • 2023. 01
      • 2022. 12
    • Business Model
      • 아이디어 불패의 법칙
      • 린 모바일 앱 개발
      • 린 스타트업
      • 제로투원
      • MIT 스타트업 바이블
      • 린치핀
    • 백로그 종합
Powered by GitBook
On this page
  • 책임에 대한 수행은 자율성이 보장되어야 한다
  • 자율적인 객체와 그렇지 못한 객체
  • '어떻게'가 아니라 '무엇'을
  • 메시지와 메서드
  • 다형성
  • 유연하고 확장 가능한 협력의 의미
  • 유연하다
  • 확장 가능하다
  • 송신자와 수신자를 약하게 연결하는 메시지
  • '어떻게'가 아니라 '무엇' 이다
  • 인터페이스 설계 원칙
  • 책임의 자율성이 협력의 품질을 결정한다
  • 어떤 설계가 좋은 설계일까
  • 1. 자율적인 책임은 협력을 단순하게 만든다.
  • 2. 자율적인 책임은 외부와 내부를 명확하게 분리한다.
  • 3. 객체가 수행하는 책임이 자율적일수록 객체의 역할을 이해하기 쉬워진다.
  1. 도서
  2. 객체지향의 사실과 오해

CH05 책임과 메시지

PreviousCH04 역할, 책임, 협력NextCH06 객체 지도

Last updated 1 year ago

책임에 대한 수행은 자율성이 보장되어야 한다

책의 전반에서 계속해서 객체의 책임을 강조하고 있는데, 책임 자체 뿐만이 아니라 책임을 가진 객체가 이를 자율적으로 처리할 수 있어야 한다는 것도 강조하고 있다. 객체의 자율성이 보장될 수록 설계의 품질이 좋아지기 때문이다. 자세한 사항은 뒤에서 더 말하고 있는데 일단 자율적이지 못한 객체와 자율적인 객체의 차이를 알아보자.

자율적인 객체와 그렇지 못한 객체

그림 5.1이 자율성이 보장된 객체이고 그림 5.2가 자율성이 제한된 객체의 모습이다.

그림 5.1 에서는 객체가 증언할 책임은 있지만 증언을 위해서 구체적으로 방법이나 절차등이 강제되지 않은 상황이다. 즉, 증언만 '알아서 잘' 하면 되는 것이지 세세하게 절차나 세부사항등에 대해서 강제되지 않았다.

반면에 그림 5.2에서는 증언이라는 책임을 위해서 상위 객체가 세세하게 방법까지 강제하고 있다. 책임 수행은 하고 있지만 전혀 자유롭지 못하고 시키는대로 해야만 하는 객체가 되었다.

둘다 결국 협력이라고 표현할 수는 있지만 객체의 자율성에서 큰 차이가 난다.

'어떻게'가 아니라 '무엇'을

자율적인 책임의 특징은 객체가 '어떻게' 해야 하는가가 아니라 '무엇'을 해야 하는가를 설명한다는 것이다. 위 예시에서 이미 이러한 모습을 확인할 수 있었다.

메시지와 메서드

특별한 내용은 아니었고, 메시지와 메서드의 개념을 다시 짚어보는 내용이었다. 객체간 협력을 위해서 요청 및 응답을 하는 수단이 바로 메시지이다. 메서드는 이렇게 메시지를 받았을 때 내부적으로 책임을 수행하고 응답을 하기위해서 '자율적으로' 선택하고 이용하는 말그대로 메서드를 뜻한다.

핵심적인 내용은 메시지는 객체들이 서로 협력하기 위해서 사용할 수 있는 유일한 의사소통 수단이라는 것이며, 메시지를 받은 객체는 내부적으로 알아서 메서드를 선택하여 책임을 수행하게 된다는 것이다.

다형성

다형성에 대해서 설명한 여러 문구를 많이 봐왔지만 이 책에서 정리된 문구가 마음에 들어서 그대로 가져왔다.

다형성이란 서로 다른 유형의 객체가 동일한 메시지에 대해 서로 다르게 반응하는 것을 의미한다. 좀 더 구체적으로 말해 서로 다른 타입에 속하는 객체들이 동일한 메시지를 수신할 경우 서로 다른 메서드를 이용해 메시지를 처리할 수 있는 메커니즘을 가리킨다.

더 줄이자면 '서로 다른 객체가 동일한 메시지에 대해서 서로 다른 방식으로 처리하는 것'이라고 할 수 있겠다. 1 개의 메시지 N 개의 메서드라고도 표현할 수 있다.

다형성 덕분에 메시지 송신자는 수신자가 누가 될지에 관해서 신경쓸 필요가 전혀 없고 누가 처리해주든 이 요청을 처리해 줄 것이라는 믿음을 가지고 송신자 본인의 책임에 집중하면 된다. 이는 곧 설계가 더 유연하고 확장 가능한 구조라는 것을 의미한다.

유연하고 확장 가능한 협력의 의미

다형성을 발휘할 수록 더 유연하고 확장 가능한 협력 구조가 나온다. 이를 자세히 이해해보자.

유연하다

다형성을 사용하면 송신자는 수신자가 누구인지 신경쓰지 않고 메시지를 보낼 수 있다. 메시지 수신자에 대한 관심을 완전히 없애버릴 수 있는 것이다. 이를 수신자 입장에서 보면 송신자에 대한 파급 효과 없이 편하게 변경할 수 있다. 수신자 입장에서 유연하게 변경 사항에 대한 수용이 가능하다는 것이다.

확장 가능하다

이것도 결국 수신자가 송신자에게 파급 효과가 없는 덕분이다. 도메인의 변경사항이 생겨서 이를 처리할 수신자가 더 필요한 경우가 생겨도 송신자에게 아무런 파급 효과가 없다. 그래서 수신자를 더 늘리는 것이 매우 쉬워진다.

송신자와 수신자를 약하게 연결하는 메시지

이처럼 다형성은 좋은 구조의 협력을 만들어내고, 이러한 다형성을 근본적으로 지탱하는 것은 객체들간에 주고 받는 메시지이다. 메시지는 송신자와 수신자 사이의 결합도를 낮춤으로써 설계를 유연하고 확장 가능하게 해준다.

메시지를 기반으로 한 두 객체 사이의 이 낮은 결합도가 바로 설계를 유연하고 확장 가능하며 재사용 가능하게 만드는 비결이다.

다시 강조되는 부분인데, 그래서 객체를 설계할 때 객체 자체에 집중하면 안되고 협력이라는 큰 문맥에서 '어떤 메시지를 통해서 협력이 발생할 것인가'에 집중하고 이러한 메시지를 기반으로 협력하는 객체들의 관계를 발견해야한다. 이 과정 속에서 객체에게 책임이 부여되는 것이다.

객체지향 설계는 적절한 책임을 적절한 객체에게 할당하면서 메시지를 기반으로 협력하는 객체들의 관계를 발견하는 과정이다.

객체가 어떤 메시지를 수신하고 처리할 수 있느냐가 객체의 책임을 결정한다. 책임-주도 설계 방법에서는 What/Who 사이클에 따라 협력에 참여할 객체를 결정하기 전에 협력에 필요한 메시지를 먼저 결정한다. 메시지가 결정된 후에야 메시지를 수신할 후보를 선택하는 것으로 초점이 이동한다.

결국 설계시 최우선 고려 사항은 '메시지' 이다. 메시지가 곧 협력이라는 추상적 개념의 구체적 조각이다.

'어떻게'가 아니라 '무엇' 이다

메시지가 '어떻게' 해야 하는지를 지시하지 말고 '무엇'을 해야 하는지를 요청해야한다. '어떻게'에서 '무엇'으로 전환하는 것은 객체 인터페이스의 크기를 급격하게 감소시킨다. 인터페이스의 크기가 작다는 것은 외부에서 해당 객체에게 의존해야 하는 부분이 적어진다는 것을 의미한다. 결과적으로 메시지 송신자와 수신자 간의 결합도가 낮아지기 때문에 설계를 좀 더 유연하게 만들 여지가 많아지고 의도 역시 명확해진다.

인터페이스 설계 원칙

객체 인터페이스(여기서 말하는 인터페이스는 특정 언어의 interface 를 말하는게 아니고 외부와 맞닿은 노출된 인터페이스를 의미한다) 설계시 아래 세 가지를 기억하자.

  • 좀 더 추상적인 인터페이스(구체적일 수록 자율성이 떨어진다)

  • 최소 인터페이스

  • 인터페이스와 구현 간에 차이가 있다는 점을 인식(캡슐화에 신경쓰자는 의미)

책임의 자율성이 협력의 품질을 결정한다

어떤 설계가 좋은 설계일까

설계의 우수함과 같은 것은 수치화 할 수 없는 것이므로 동일한 설계를 두고도 사람마다 의견이 다를 수 있다. 그렇다면 어떠한 설계가 더 좋은 설계라고 말할 수 있을까? 책에서는 그 기준으로 '다른 협력보다 이해하기 쉬워지고 유연하게 변경할 수 있는 것'을 제시한다.

그리고 협력이 이해하기 쉽고 유연하게 변경 가능하려면 객체들이 최대한의 자율성을 보장 받아야 한다. 책임이 얼마나 자율적인지가 전체적인 협력의 설계 품질을 결정하게 된다.

1. 자율적인 책임은 협력을 단순하게 만든다.

책임을 적절하게 추상화 함으로써 책임의 자율성을 보장해준다. 자율적인 책임은 의도를 명확하게 표현함으로써 협력을 단순화 하고 이해하기 쉽게 만든다. 앞서 살펴본 예시로 How 를 줄줄 나열할 것이 아니라 What 으로 간단하게, 적절한 추상화를 한 수준으로 메시지를 전달하면 자율성이 증대된다.

2. 자율적인 책임은 외부와 내부를 명확하게 분리한다.

자율적인 책임을 바탕으로 설계된 객체는 캡슐화가 잘 된다. 캡슐화가 잘 되어야만 변경이 용이해진다. 파급효과가 미칠 수 없는 안전지대가 마련되기 때문이다. 내부에 감출 수 있는, 안전지대를 이용해서 객체의 자율성이 보장될 수 있다.

캡슐화가 잘 될수록 변경의 파급효과가 객체를 넘어서 다른 객체로 전파되지 않고, 이를 위해서는 외부와 내부를 명확하게 분리하는 것이 중요하다. 이는 곧 객체간의 결합도를 낮추는 길이다.

3. 객체가 수행하는 책임이 자율적일수록 객체의 역할을 이해하기 쉬워진다.

인간의 인지능력 자체에 대한 한계를 전제한 이야기이다. 객체가 수행하는 책임들이 자율적이면 자율적일수록 객체의 존재 이유를 명확하게 표현할 수 있다. 객체의 책임이 자율적일 수록 객체의 응집도를 높은 상태로 유지하기가 쉬워진다.

책에서는 다섯가지를 말하고 있는데 내가 요약하는 과정에서 일부를 합치고, 축약해서 세 가지로 만들었다. 결론적으로 이번 장에서는 메시지의 역할과 중요성이 강조되었다.