네로개발일기

개발자 네로의 개발 일기, 자바를 좋아합니다 !

'2022/04'에 해당되는 글 17건


반응형

객체 지향의 4대 특성

1. 캡슐화: 정보 은닉

2. 상속: 재사용

3. 추상화: 모델링

4. 다형성: 사용편의

 

추상화: 모델링

객체 지향의 추상화는 곧 모델링이다.

추상화란, 구체적인 것을 분해해서 관찰자가 관심있는 특성만 가지고 재조합하는 것이다.

 

  • 객체: 세상에 존재하는 유일무이한 사물
  • 클래스: 같은 속성과 기능을 가진 객체를 총칭하는 개념

개발자가 필요한 객체는 Context(애플리케이션 경계)에 따라 달라질 수 있다.

=> 추상화란, 구체적인 것을 분해해서 관심 영역(애플리케이션)에 있는 특성만 가지고 재조합하는 것을 말한다. (모델링)

자바는 이러한 객체 지향의 추상화를 class 키워드를 통해 지원하고 있다.

 

상속: 재사용 + 확장 (extends)

상속은 계층적인 개념이 아닌 재사용과 확장으로 이해하는 것이 맞다.

상속은 분류도다.

상위 클래스로 갈수록 추상화/일반화가 되고, 하위 클래스로 갈수록 구체화/특수화가 진행된다.

 

리스코프 치환 법칙

  • 하위 클래스는 상위 클래스이다.
  • is a kind of 

상속과 인터페이스

인터페이스는 be able to 와 같이 '무엇을 할 수 있는' 형태로 만드는 것이 좋다.

 

자바 API 예시

  • Comparable 인터페이스: 비교할 수 있는
  • Runnable 인터페이스: 실행할 수 있는

 

인터페이스는 클래스가 무엇을 할 수 있다는 기능을 구현하도록 강제하게 된다.

 

  • 리스코프 치환 원칙에 의해 상위 클래스가 풍성할수록 좋다.
  • 인터페이스 분할 원칙에 의해 인터페이스 메서드는 적을수록 좋다.

 

다형성: 사용편의성

객체지향에서 다형성은 오버라이딩오버로딩이다.

 

  • 오버라이딩: 같은 메서드 이름, 같은 인자 목록으로 상위 클래스의 메서드를 재정의
  • 오버로딩: 같은 메서드 이름, 다른 인자 목록으로 다수의 메서드를 중복 정의

 

상위 클래스 타입의 객체 참조 변수를 사용하더라도 하위 클래스에서 오버라이딩한 메서드가 호출된다.

 

캡슐화: 정보 은닉

접근 제어자: private, protected, public

  • public: 모두가 접근 가능
  • protected: 상속/ 같은 패키지 내의 클래스에서 접근 가능
  • [default]: 같은 패키지 내의 클래스에서 접근 가능
  • private: 본인만 접근 가능
728x90
반응형
blog image

Written by ner.o

개발자 네로의 개발 일기, 자바를 좋아합니다 !

반응형

파일 문자셋 확인 라이브러리 / Encoding Detector / juniversalchardet 

파일의 문자셋 encoding을 확인하고 싶을 때 사용하는 라이브러리이다.

감지할 수 있는 인코딩 종류

  • Chinese
    • ISO-2022-CN
    • BIG-5
    • EUC-TW
    • HZ-GB-2312
    • GB-18030
  • Cyrillic
    • ISO-8859-5
    • KOI8-R
    • WINDOWS-1251
    • MACCYRILLIC
    • IBM866
    • IBM855
  • Greek
    • ISO-8859-7
    • WINDOWS-1253
  • Hebrew
    • ISO-8859-8
    • WINDOWS-1255
  • Japanese
    • ISO-2022-JP
    • Shift_JIS
    • EUC-JP
  • Korean
    • ISO-2022-KR
    • EUC-KR
  • Unicode
    • UTF-8
    • UTF-16BE / UTF-16LE
    • UTF-32BE / UTF-32LE / X-ISO-10646-UCS-4-3412 / X-ISO-10646-UCS-4-2143
  • Others
    • WINDOWS-1252
    • US-ASCII

 

Dependency

사용하기 위해선 dependency를 추가해줘야 한다.

maven인 경우 pom.xml에 다음 dependency를 추가한다.

<dependency>
	<groupId>com.github.albfernandez</groupId>
	<artifactId>juniversalchardet</artifactId>
	<version>2.4.0</version>
</dependency>

gradle인 경우 build.gradle에 다음 dependency를 추가한다.

implementation 'com.github.albfernandez:juniversalchardet:2.4.0'

 

Sample Code

import org.mozilla.universalchardet.UniversalDetector;

public class TestDetectorFile {

	public static void main (String[] args) throws java.io.IOException {
		if (args.length != 1) {
			System.err.println("Usage: java TestDetectorFile FILENAME");
			System.exit(1);
		}
		java.io.File file = new java.io.File(args[0]);
		String encoding = UniversalDetector.detectCharset(file);
		if (encoding != null) {
			System.out.println("Detected encoding = " + encoding);
		} else {
			System.out.println("No encoding detected.");
		}
	}
}

 

 출처 

https://github.com/albfernandez/juniversalchardet

 

GitHub - albfernandez/juniversalchardet: Originally exported from code.google.com/p/juniversalchardet

Originally exported from code.google.com/p/juniversalchardet - GitHub - albfernandez/juniversalchardet: Originally exported from code.google.com/p/juniversalchardet

github.com

 

728x90
반응형
blog image

Written by ner.o

개발자 네로의 개발 일기, 자바를 좋아합니다 !

반응형

The difference between String.valueOf and + ""(concatenation with empty string)

일을 하다가 발견한 코드...

int seqNo = 1;
System.out.println(seqNo + "");

충격적이었다. 나는 분명 String.valueOf() 메서드나 Integer.toString() 메서드를 기대했지만 왜... + "" 나오는 것인가.

 

아무튼 String.valueOf()를 찾아봤다. 

// String.java

public static String valueOf(int i) {
    return Integer.toString(i);
}

Integer.toString()을 반환한다.

// Integer.java

public static String toString(int i) {
    if (i == Integer.MIN_VALUE)
        return "-2147483648";
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    getChars(i, size, buf);
    return new String(buf, true);
}

int 범위에 맞게 크기를 설정해주고 하나씩 넣어준다.

 

그리고 두 번째 의문, 빈 문자열을 + 연산으로 문자열 연결을 해주는 것과 String.valueOf() 메서드와의 성능 차이는 얼마나 있을까?

// 빈 문자열을 연결해줄 경우, StringBuilder를 사용해서 String을 만들어준다.
public void foo(){
    int intVar = 5;
    String strVar = intVar+"";    
}
public void foo();
  Code:
   0:   iconst_5
   1:   istore_1
   2:   new     #2;			//class java/lang/StringBuilder
   5:   dup
   6:   invokespecial   #3;	//Method java/lang/StringBuilder."<init>":()V
   9:   iload_1
   10:  invokevirtual   #4;	//Method java/lang/StringBuilder.append:(I)Ljava/lan
g/StringBuilder;
   13:  ldc     #5; 		//String
   15:  invokevirtual   #6; //Method java/lang/StringBuilder.append:(Ljava/lang/
String;)Ljava/lang/StringBuilder;
   18:  invokevirtual   #7; //Method java/lang/StringBuilder.toString:()Ljava/la
ng/String;
   21:  astore_2
   22:  return

 

// String.valueOf()를 사용할 경우, String의 static 메서드를 사용한다.
public void bar(){
    int intVar = 5;
    String strVar = String.valueOf(intVar);
}
public void bar();
  Code:
   0:   iconst_5
   1:   istore_1
   2:   iload_1
   3:   invokestatic    #8; //Method java/lang/String.valueOf:(I)Ljava/lang/Stri
ng;
   6:   astore_2
   7:   return

 

String.valueOf() 메서드를 사용하여 문자열로 바꿔주는 것이 좀 더 효율적이다.

 

 출처 

https://stackoverflow.com/questions/7752347/string-valueof-vs-concatenation-with-empty-string

 

String valueOf vs concatenation with empty string

I am working in Java code optimization. I'm unclear about the difference between String.valueOf or the +"" sign: int intVar = 1; String strVar = intVar + ""; String strVar = String.valueOf(intVar);

stackoverflow.com

 

728x90
반응형
blog image

Written by ner.o

개발자 네로의 개발 일기, 자바를 좋아합니다 !

반응형

 이전 글 

https://frogand.tistory.com/114

 

[Spring] @RequestBody, @RequestParam, @ModelAttribute의 차이

Client에서 받은 요청을 객체로 바인딩하기 위해 사용하는 방법에는 총 @RequestBody, @RequestParam, @ModelAttribute 총 3가지가 있다. 🥑 @RequestParam @RequestParam은 1개의 HTTP 요청 파라미터를 받기 위해..

frogand.tistory.com

https://frogand.tistory.com/162

1. @RequestBody와 @ModelAttribute

// Controller.java
@PostMapping
public ResponseEntity<String> createPost(@ModelAttribute PostDto postDto) {
}

@PostMapping
public ResponseEntity<String> createComment(@RequestBody CommentDto commentDto) {
}

@RequestBody와 @ModelAttribute는 클라이언트 측에서 보낸 데이터를 Java 코드에서 사용할 수 있는 오브젝트로 만들어주는 공통점이 있다. 하지만 두 어노테이션은 세부 수행 동작에서 큰 차이가 있다. 

 

2. @RequestBody

Annotation indicating a method parameter should be bound to the body of the web request. The body of the request is passed through an HttpMessageConverter to resolve the method argument depending on the content type of the request.

POST HTTP1.1 /requestbody
Body:
{ “password”: “1234”, “email”: “kevin@naver.com” }

@RequestBody 어노테이션의 역할은 클라이언트가 보내는 HTTP 요청 본문(JSON, XML 등)을 Java 객체로 변환하는 것이다. HTTP 요청 본문 데이터는 Spring에서 제공하는 HttpMessageConverter를 통해 타입에 맞는 객체로 변환된다.

 

// Controller.java

@PostMapping("/requestbody")
public ResponseEntity<RequestBodyDto> testRequestBody(@RequestBody RequestBodyDto dto) {
    return ReponseEntity.ok(dto);
}
// RequestBodyDto.java

@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
public class RequestBodyDto {

    private String name;
    private long age;
    private String password;
    private String email;
}
// ControllerTest.java

@Test
void requestsBody() throws Exception {
    
    ObjectMapper objectMapper = new ObjectMapper();
    RequestBodyDto dto = new RequestBodyDto("req", 1L, "pass", "email");
    String requestBody = objectMapper.writeValueAsString(dto);
    
    mockMvc.perform(post("/requestbody")
           .contentType(MediaType.APPLICATION_JSON_VALUE)
           .content(requestBody))
           .andExpect(status().isOk())
           .andExpect(jsonPath("name").value("req"))
           .andExpect(jsonPath("age").value("1"))
           .andExpect(jsonPath("password").value("pass"))
           .andExpect(jsonPath("email").value("email"));
}

RequestBodyDto 객체를 JSON 문자열로 변환한 뒤, 이를 Post 요청 본문에 담아 보내고 다시 응답 본문으로 받는 테스트이다. 해당 테스트를 실행하면 요청 본문의 JSON 값이 DTO로 잘 변환되어 성공한다.

 

1) 생성자와 setter가 없다면?

// RequestBodyDto.java

@NoArgsConstructor // 기본 생성자
// @AllArgsConstructor
@Getter
// @Setter
public class RequestBodyDto {

    private String name;
    private long age;
    private String password;
    private String email;
}
// ControllerTest.java

@Test
void requestBody() throws Exception {
    String requestBody = "{\"name\":\"req\",\"age\":1,\"password\":\"pass\",\"email\":\"email\"}\n";

    mockMvc.perform(post("/requestbody")
            .contentType(MediaType.APPLICATION_JSON_VALUE)
            .content(requestBody))
            .andExpect(status().isOk())
            .andExpect(jsonPath("name").value("req"))
            .andExpect(jsonPath("age").value("1"))
            .andExpect(jsonPath("password").value("pass"))
            .andExpect(jsonPath("email").value("email"));
}

RequestBodyDto의 필드를 바인딩해줄 수 있는 생성자 및 setter 메서드를 삭제하고 테스트를 실행해도 테스트는 성공한다.

어떻게 기본 생성자만을 가지고 JSON 값을 Java 객체로 재구성할 수 있을까?

2) MappingJackson2HttpMessageConverter

org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver 클래스의 readWithMessageConverters()라는 메서드에 브레이크 포인트를 찍고 다시 Post 요청을 보내면, Spring에 등록된 여러 MessageConverter 중 MappingJackson2HttpMessageConverter를 사용한다.

 

내부적으로 ObjectMapper를 통해 JSON 값을 Java 객체로 역직렬화하는 것을 알 수 있다. 역직렬화란 생성자를 거치지 않고 리플렉션을 통해 객체를 구성하는 매커니즘이다. 직렬화 가능한 클래스들은 기본 생성자가 항상 필수이다. 따라서 @RequestBody에 사용하려는 RequestBodyDto가 기본 생성자를 정의하지 않으면 데이터 바인딩에 실패한다.

 

어떻게 ObjectMapper는 JSON에 명시된 필드명 Key를 Java 객체의 필드명에 매핑시켜 값을 대입할까?

How Jackson ObjectMapper Matches JSON Fields to Java Fields
To read Java objects from JSON with Jackson properly, it is important to know how Jackson maps the fields of a JSON object to the fields of a Java object, so I will explain how Jackson does that.
By default Jackson maps the fields of a JSON object to fields in a Java object by matching the names of the JSON field to the getter and setter methods in the Java object. Jackson removes the "get" and "set" part of the names of the getter and setter methods, and converts the first character of the remaining name to lowercase.
For instance, the JSON field named brand matches the Java getter and setter methods called getBrand() and setBrand(). The JSON field named engineNumber would match the getter and setter named getEngineNumber() and setEngineNumber().
If you need to match JSON object fields to Java object fields in a different way, you need to either use a custom serializer and deserializer, or use some of the many Jackson Annotations.

Jackson ObjectMapper는 JSON 오브젝트의 필드를 Java 오브젝트의 필드에 매핑할 때 getter 혹은 setter 메서드를 사용한다. getter나 setter 메서드명의 접두사(get, set)를 지우고, 나머지 문자의 첫 문자를 소문자로 변환한 문자열을 참조하여 필드명을 찾아낸다.

 

RequestBodyDto에 getter 및 setter 메서드가 모두 정의되어 있지 않으면, 테스트 실행시 HttpMessageNotWritableException 예외가 발생해 실패한다.

 

3) conclusion

- @RequestBody를 사용하면 요청 본문의 JSON, XML, TEXT 등의 데이터가 적합한 HttpMessageConverter를 통해 파싱되어 Java 객체로 변환된다.

- @RequestBody를 사용할 객체는 필드를 바인딩할 생성자나 setter 메서드가 필요없다.

다만, 직렬화를 위해 기본 생성자는 필수다.

또한, 데이터 바인딩을 위한 필드명을 알아내기 위해 getter나 setter 중 한가지는 정의되어 있어야 한다.

 

3. @ModelAttribute

Annotation that binds a method parameter or method return value to a named model attribute, exposed to a web view. Supported for controller classes with @RequestMapping methods.

POST HTTP1.1 /modelattribute
Request params: id=13 name=kevin

@ModelAttribute 어노테이션의 역할은 클라이언트가 보내는 HTTP 파라미터들을 특정 Java 객체에 바인딩(매핑)하는 것이다. /modelattribute?name=req&age=1 같은 query string 형태 혹은 요청 본문에 삽입되어있는 Form 형태의 데이터를 처리한다.

// Controller.java

@Getmapping("/modelattribute")
public ResponseEntity<ModelAttributeDto> testModelAttribute(@ModelAttribute ModelAttributeDto dto) {
    return ReponseEntity.ok(dto);
}
// ModelAttributeDto.java

@AllArgsConstructor
@Getter
public class ModelAttributeDto {

    private String name;
    private long age;
    private String password;
    private String email;
}
// ControllerTest.java

@Test
void modelAttribute() throws Exception {
    mockMvc.perform(get("/modelattribute")
            .param("name", "req")
            .param("age", "1")
            .param("password", "pass")
            .param("email", "naver"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("name").value("req"))
            .andExpect(jsonPath("age").value("1"))
            .andExpect(jsonPath("password").value("pass"))
            .andExpect(jsonPath("email").value("naver"));
}

먼저, Http 파라미터와 함께 Get 요청을 테스트하자. Http 파라미터들은 URL 뒤에 붙어 /modelattribute?name=req&age=1&password=pass&email=naver 형태의 query string이 된다. 테스트 실행 결과는 ModelAttributeDto{name='req', age='1', password='pass', email='naver'}로 데이터가 잘 바인딩된다.

 

// Controller.java

@PostMapping("/modelattribute") 
public ResponseEntity<ModelAttributeDto> testModelAttribute(@ModelAttribute ModelAttributeDto dto) {
    return ResponseEntity.ok(dto);
}
// ControllerTest.java

@Test
void modelAttribute() throws Exception {
    ObjectMapper objectMapper = new ObjectMapper();
    ModelAttributeDto modelAttributeDto = new ModelAttributeDto("req", 1L, "pass", "email");
    String requestBody = objectMapper.writeValueAsString(modelAttributeDto);

    mockMvc.perform(post("/modelattribute")
            .contentType(MediaType.APPLICATION_JSON_VALUE)
            .content(requestBody))
            .andExpect(status().isOk())
            .andExpect(jsonPath("name").value("req"))
            .andExpect(jsonPath("age").value("1"))
            .andExpect(jsonPath("password").value("pass"))
            .andExpect(jsonPath("email").value("email"));
}

Post 요청 테스트를 해보자. 이 테스트를 실행하면 실패한다. @ModelAttribute는 Form 형식의 HTTP 요청 본문 데이터만을 인식해 매핑하지만, JSON 형태의 데이터를 전송하고 있다. 데이터가 바인딩되지 않거나 415 Unsupported Media Type 에러가 발생한다.

 

// ControllerTest.java

mockMvc.perform(post("/modelattribute")
        .contentType(MediaType.APPLICATION_FORM_URLENCODED)
        .content("name=req&age=1&password=pass&email=naver"))
        .andExpect(status().isOk())
        .andExpect(jsonPath("name").value("req"))
        .andExpect(jsonPath("pass").value("pass"))
        //...

이와 같이 contentType을 x-www-form-url-encoded로 요청 본문 내용을 Form 형식으로 보내도록 테스트를 수정하면 테스트 실행 결과로 ModelAttributeDto{name='req', age=1, password='pass', email='naver'}로 데이터가 잘 바인딩됨을 확인할 수 있다.

1) 생성자가 없을 때는 setter를

@RequestBody 예제처럼 필드에 접근해 데이터를 바인딩할 수 있는 ModelAttributeDto의 생성자를 삭제해보자.

// ModelAttributeDto.java

// @AllArgsConstructor
@Getter
public class ModelAttributeDto {

    private String name;
    private long age;
    private String password;
    private String email;
}

 

ModelAttributeDto{name='null', age=0, password='null', email='null'}가 출력된다. Post 요청으로 HTTP 파라미터는 정상적으로 보냈지만, Controller에서 데이터를 ModelAttributeDto에 바인딩하지 못하고 있다.

그럼 ModelAttributeDto에 setter 메서드를 추가하고 테스트를 실행하면, 테스트는 생성자가 있을 때처럼 성공하게 됩니다.

2) conclusion

- @ModelAttribute를 사용하면 HTTP 파라미터 데이터를 Java 객체에 매핑한다.

따라서, 객체의 필드에 접근해 데이터를 바인딩할 수 있는 생성자나 setter 메서드가 필요하다.

- query string 및 form 형식이 아닌 데이터는 처리할 수 없다.

 

 참고 

https://tecoble.techcourse.co.kr/post/2021-05-11-requestbody-modelattribute/

 

@RequestBody vs @ModelAttribute

1. @RequestBody와 @ModelAttribute Controller.java @RequestBody와 @ModelAttribute는 클라이언트 측에서 보낸 데이터를 Java…

tecoble.techcourse.co.kr

https://jenkov.com/tutorials/java-json/jackson-objectmapper.html#how-jackson-objectmapper-matches-json-fields-to-java-fields

 

728x90
반응형
blog image

Written by ner.o

개발자 네로의 개발 일기, 자바를 좋아합니다 !

반응형

@ModelAttribute

1. Method Level

@ModelAttribute
public void addAttributes(Model model) {
    model.addAttribute("msg", "Welcome to the Netherlands!");
}

하나 이상의 속성을 Model에 추가하고 싶을 때 메서드 레벨에서 @ModelAttribute를 추가해준다. 일반적으로 Spring MVC는 요청 핸들러 메서드를 호출하기 전에 항상 해당 메서드를 먼저 호출한다. 즉, @RequestMapping 어노테이션이 달린 컨트롤러 메서드가 호출되기 전에 @ModelAttribute 어노테이션이 달린 메서드가 호출된다. 시퀀스의 논리는 컨트롤러 메서드 내에서 처리가 시작되기 전에 모델 개체를 만들어야한다는 것이다.

 

2. Method Argument Level

@ModelAttribute는 여러 곳에 있는 단순 데이터 타입을 복합 타입 객체로 받아오거나 해당 객체를 새로 만들 때 사용할 수 있다.

여러 곳은 URI path, 요청 매개변수, 세션 등을 의미한다.

복합 객체에 데이터 바인딩을 하는 방법은 @RequestParameter로만 전달되어야하는 것은 아니다.

유연하게 여러 데이터를 하나의 복합 타입 객체로 받아올 수 있다.

 

 

만약 값을 바인딩할 수 없는 경우라면 BindException이 발생하고 400 에러가 발생한다.

만약 바인딩 에러를 직접 다루고 싶은 경우라면 @ModelAttribute가 붙은 메서드에 BindingResult 파라미터를 추가하면 된다.

@Controller
@RequestMapping("/event")
public class SampleController {
    
    @PostMapping("/names/{name}")
    @ResponseBody
    public Event getEvent(@ModelAttribute Event event, BindingResult bindingResult) {
        if(bindingResult.hasErrors()) {
            bindingResult.getAllErrors().forEach( c -> {
                System.out.println(c.toString());
            });
        }
        
        return event;
    }
}

 

바인딩 이후 검증 작업을 추가로 진행하고 싶다면 @Valid 또는 @Validated 어노테이션을 사용할 수 있다.

// Event.java
@Getter
@Setter
public class Event {

    private Long id;
    private String name;
    
    @Min(0)
    private Integer limit;
}

// SampleController.java
@Controller
@RequestMapping("/event")
public class SampleController {
    
    @PostMapping("/names/{name}")
    @ResponseBody
    public Event getEvent(@Valid @ModelAttribute Event event, BindingResult bindingResult) {
        if(bindingResult.hasErrors()) {
            bindingResult.getAllErrors().forEach( c -> {
                System.out.println(c.toString());
            });
        }
        
        return event;
    }
}

@Validated

스프링 MVC 핸들러 메서드 아규먼트에 사용할 수 있으며, Validation group 이라는 힌트를 사용할 수 있다.

@Valid 어노테이션에는 그룹을 지정할 방법이 없지만 @Validated는 스프링이 제공하는 어노테이션으로 그룹 클래스를 설정할 수 있다.

 

 참고 

https://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation

https://minkukjo.github.io/framework/2020/04/13/Spring-85/

 

Spring MVC 핸들러 메소드 @ModelAttribute

Spring Web MVC

minkukjo.github.io

 

728x90
반응형
blog image

Written by ner.o

개발자 네로의 개발 일기, 자바를 좋아합니다 !