자바 성능 튜닝 - 클래스 정보

By starseat
2024-05-08 09:45:52
java/spring

Post Tags

[자바 성능 튜닝 이야기](https://product.kyobobook.co.kr/detail/S000001032977) 책을 읽고 정리한 내용 입니다.

---

자바에는 `Class` 클래스와 `Method` 클래스로 클래스와 메서드의 정보를 확인할 수 있는 API 가 있다.

# reflection 관련 클래스들

자바 API에는 reflection 이라는 패키지가 있다.
이 패키지에 있는 클래스들을 사용하면 JVM에 로딩되어 있는 클래스와 메서드 정보를 읽어올 수 있다.
간단하게 살펴보자.

## Class 클래스

클래스에 대한 정보를 얻을 때 사용하기 좋다.
ClassLoader 클래스의 defineClass() 메서드를 이용해서 클래스 객체를 만들 수도 있지만 좋은 방법은 아니다.
그보다는 Object 클래스에 있는 getClass() 메서드를 이용하는 것이 일반적이다.

현재 클래스의 이름을 알고 싶으면 다음과 같이 사용하면 된다.

```java
String currentClassName = this.getClass().getName();  // 패키지 정보 포함
String currentClassSimpleName = this.getClass().getSimpleName(); // 클래스 이름만
```

## Method 클래스

`Method` 클래스를 이용하여 메서드에 대한 정보를 얻을 수 있다.
`Method` 클래스는 생성자가 없으므로 `Class` 클래스의 `getMethod(), getDeclaredMethod()` 등을 사용하여야 한다.

## Field 클래스

`Field` 클래스는 클래스에 있는 변수들의 정보를 제공한다.
`Method` 클래스와 마찬가지로 생성자가 존재하지 않아 `Class` 클래스의 `getField(), getDeclaredFields()` 등의 메서드를 사용해야 한다.

# reflection 관련 클래스 사용 예

- DemoClass

```java
public class DemoClass {
	// field (변수)
	private String privateField;
	String field;
	protected String protectedField;
	public String publicField;

// Constructor (생성자)
	public DemoClass() {}
	public DemoClass(String arg) {}

// Method (메서드)
	public void publicMethod() throws java.io.IOException, Exception {}
	public String publicMethod(String s, int i) {
		return "s=" + s + ", i=" + i;
	}

protected void protectedMethod() {}
	private void privateMethod() {}
	void method() {}

public String publicRetMethod() {
		return null;
	}
	public InnerClass getInnerClass() {
		return new InnerClass();
	}

public class InnerClass {}
}
```
- DemoTest - 위의 DemoClass 테스트

```java
import java.lang.reflect.*;

public class DemoTest {
	public static void main(String[] args) {
		DemoClass dc = new DemoClass(); // 점검 대상 클래스 객체 생성

DemoTest dt = new DemoTest();
		dt.getClassinfos(dc);
	}

public void getClassInfos(Object cls) {
		Class demoClass = cls.getClass();

getClassInfo(demoClass);
		getFieldInfo(demoClass);
		getMethodInfo(demoClass);
	}

public void getClassInfo(Class demoClass) {
		System.out.println("[getClassInfo]");
		System.out.format("Class Name: %s\n", demoClass.getName());
		System.out.format("Class Canonical Name: %s\n", demoClass.getCanoicalName());
		System.out.format("Class Simple Name: %s\n", demoClass.getSimpleName());
		System.out.format("Paclage Name: %s\n", demoClass.getPackage().getName());
		System.out.format("toString: %s\n", demoClass.toString());
	}

public void getFieldInfo(Class demoClass) {
		System.out.println("----------\n[getFieldInfo]");

Field[] field1 = demoClass.getDeclaredFields();
		Field[] field2 = demoClass.getFields();
		System.out.format("Declared Fields size: %d, Fields size: %d", 
			field1.length, field2.length);

for (Field field : field1) {
			System.out.format("%s %s %s\n",
				field.getName(),
				Modifier.toString(field.getModifiers()),
				Modifier.toString(modifier),
				field.getType().getSimpleName()
			);
		}
	}

public void getMethodInfo(Class demoClass) {
		System.out.println("----------\n[getMethodInfo]");
		
		Method[] method1 = demoClass.getDeclaredMethods();
		Method[] method2 = demoClass.getMethods();
		System.out.format("Declared Methods size: %d, Methods size: %d", 
			method1.length, method2.length);

for(Method met : method1) {
			String methodName = met.getName();
			String modifierStr = Modifier.toString(met.getModifiers());
			String returnType = met.getReturnType().getSimpleName();
			
			// method parameter info
			Class[] params = met.getParameterTypes();
			StringBuilder paramSb = new StringBuilder();
			int paramLen = params.length;

if(paramLen > 0) {
				paramSb.append(params[0].getSimpleName()).append(" arg");
				for(int i=0; i<paramLen; i++) {
					paramSb.append(",").append(params[i].getName())
						.append(" arg").append(i);
				}
			}

// method excepion info
			Class[] exceptions = met.getExceptionTypes();
			StringBuilder exceptionSb = new StringBuilder();
			int exceptionLen = exceptions.length;
			if (exceptionLen > 0) {
				exceptionSb.append("throws").append(exceptions[0].getSimpleName());
				for(int i=0; i<exceptionLen; i++) {
					exceptionSb.append(",")
						.append(exceptions[i].getSimpleName());
				}
			}

// print result
			System.out.format("%s %s %s(%s) %s\n",
				modifierStr, returnType, methodName, 
				paramSb.toString(), exceptionSb.toString());
		}
	}
}
```

- 실행 결과

```text
[getClassInfo]
Class Name: com.perf.feflect.cls.DemoClass
Class Cononical Name: com.perf.feflect.cls.DemoClass
Class Simple Name: DemoClass
Package Name: com.perf.feflect.cls
toString: class com.perf.feflect.cls.DemoClass
----------
[getFieldInfo]
Declared Methods size: 4, Methods size: 1
private String privateField
String field
protected String protectedField
public String publicField
----------
[getMethodInfo]
Declared Methods size: 7, Methods size: 13
public String publicMethod(String arg,int arg1)
public void publicMethod() throws IOException,Exception
protected void protectedMethod()
private void privateMethod()
public String publicRetMethod()
public InnerClass getInnerClass()
void method()
```

# reflection 잘못 사용 사례

일반적으로 클래스 이름을 알아내기 위해 다음과 같이 사용한다. (주로 로그찍을때)

```java
this.getClass().getName()
```

이 방법을 사용한다고 해서 성능에 많은 영향을 미치지는 않는다.
다만 getClass() 메서드를 호추할 때마다 `class` 객체를 생성하고, 그 객체의 이름을 가져오는 메서드를 수행하게 된다.

간혹 reflection 관련 클래스를 사용하여 다음과 같이 사용할 때도 있다.
reflection 관련 클래스를 사용할 경우 응답 속도에 많은 영향을 주지는 않지만, 이런 코드가 많을 수록 필요없는 시간을 낭비하게 된다.

```java
// src 는 Object 타입
if(src.getClass().getName().equals("java.math.BigDecimal")) { } // bad case
if(src instanceof java.math.BigDecimal) {} // good case
```

책에서 100번 수행한 이 둘의 성능 측정 결과 이다.

| 대상 | 응답 시간 (ms) |
| -- | -- |
| instanceof | 0.167 |
| Reflection | 1.022 |

# 정리

만약 로그에 클래스명을 표시하려고 하면 클래스 객체를 얻기보단 이름을 직접 명시하는 것이 낫다.

```java
// 클래스명 표시
String logMessage = "log message..";
log.info("[%s] %s", this.getClass().getName(), logMessage); // bad case
log.info("[TestClass] %s", logMessage); // good case
```

Previous Post 자바 성능 튜닝 - static

Next Post 자바 성능 튜닝 - Thread, synchronized