static bool sendPayload(SSL *sslPtr, char *deviceTokenBinary, char *payloadBuff, size_t payloadLength)
{
        bool rtn = false;
        if (sslPtr && deviceTokenBinary && payloadBuff && payloadLength) {
        uint8_t command = 1; /* command number */ 
        char binaryMessageBuff[sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t)
                + sizeof(uint16_t) + DEVICE_BINARY_SIZE + sizeof(uint16_t) + MAXPAYLOAD_SIZE];
        
        /* message format is, |COMMAND|ID|EXPIRY|TOKENLEN|TOKEN|PAYLOADLEN|PAYLOAD|  */
        char *binaryMessagePt = binaryMessageBuff; 
        uint32_t whicheverOrderIWantToGetBackInAErrorResponse_ID = 1234; 
        uint32_t networkOrderExpiryEpochUTC = htonl(time(NULL)+86400); 
        // expire message if not delivered in 1 day 

        uint16_t networkOrderTokenLength = htons(DEVICE_BINARY_SIZE); 
        uint16_t networkOrderPayloadLength = htons(payloadLength);
        
        /* command */ 
        *binaryMessagePt++ = command;
        
        /* provider preference ordered ID */
        memcpy(binaryMessagePt, &whicheverOrderIWantToGetBackInAErrorResponse_ID, sizeof
                                                                                                                (uint32_t));
        binaryMessagePt += sizeof(uint32_t);

        /* expiry date network order */ 
        memcpy(binaryMessagePt, &networkOrderExpiryEpochUTC, sizeof(uint32_t)); 
        binaryMessagePt += sizeof(uint32_t);
        
        /* token length network order */ 
        memcpy(binaryMessagePt, &networkOrderTokenLength, sizeof(uint16_t)); 
        binaryMessagePt += sizeof(uint16_t);

        /* device token */ 
        memcpy(binaryMessagePt, deviceTokenBinary, DEVICE_BINARY_SIZE); 
        binaryMessagePt += DEVICE_BINARY_SIZE;

        /* payload length network order */ 
        memcpy(binaryMessagePt, &networkOrderPayloadLength, sizeof(uint16_t)); 
        binaryMessagePt += sizeof(uint16_t);

        /* payload */ 
        memcpy(binaryMessagePt, payloadBuff, payloadLength); 
        binaryMessagePt += payloadLength; 
        
        if (SSL_write(sslPtr, binaryMessageBuff, (binaryMessagePt -binaryMessageBuff)) > 0) 
                rtn = true;
        } 
        return rtn;
}

String password = "1q2w3e4r";
String certicatePath = "/home/CertificateSR/Interesting_Dev_Cert_pass.p12";
String apnsAddress = "gateway.sandbox.push.apple.com";
String apnsPort = "2195";

try {
        PayLoad payload = new PayLoad();
                                
        payload.addAlert(pushMessage.getAlert());
        payload.addBadge(pushMessage.getBadge());
        payload.addSound(pushMessage.getSound());
                                
        HashMap customMap =  (HashMap) pushMessage.getCustomData(); 
        Iterator iterator = customMap.keySet().iterator();
        
        while (iterator.hasNext()) {
                String key = iterator.next();
                payload.addCustomDictionary(key, customMap.get(key));
        }
                                
        PushNotificationManager manager = PushNotificationManager.getInstance();
                        
        manager.addDevice("myIphone", pushMessage.getDeviceToken());
        
        Device device = PushNotificationManager.getInstance().getDevice("myIphone");
        manager.initializeConnection( apnsAddress, 
                                          Integer.parseInt(apnsPort), 
                                          certicatePath, 
                                          password,                                                                            
                                          SSLConnectionHelper.KEYSTORE_TYPE_PKCS12);
        manager.sendNotification(device, payload);

        manager.stopConnection();
        manager.removeDevice("myIphone");
                                
} catch (Exception e) {
        e.printStackTrace();
}

(BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
        // 배지넘버 초기화
        application.applicationIconBadgeNumber = 0;

        NSDictionary *aps = 
          [launchOptionsobjectForKey:UIApplicationLaunchOptionsRemoteNotificationKey];
        
        // 애플리케이션을 처음실행 : RemoteNotification을 등록함
        if (aps == nil) {       
                [[UIApplication sharedApplication]              
                                                registerForRemoteNotificationTypes:
                                                        (UIRemoteNotificationTypeAlert | 
                                                         UIRemoteNotificationTypeSound | 
                                                         UIRemoteNotificationTypeBadge)

                ];
                        
        } else {
                // 애플리케이션이 원격 통보에 의해 실행됐음
                // alert 추출 
                NSString *alert = [aps objectForKey:@"alert"];
                // custom 데이터 추출 
                NSString *pushSeq = [userInfo objectForKey:@"pushSeq"];
        }

        return YES;

}

// RemoteNotification 등록 성공. deviceToken을 수신
(void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
        // Provider에게 DeviceToken 전송
        //[service registDeviceToken:[deviceToken description]];
}


// APNS 에 RemoteNotification 등록 실패
(void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
        NSLog(@"fail RemoteNotification Registration: %@", [error description]);
}


// 애플리케이션 실행 중에 RemoteNotification 을 수신
(void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {
        // push 메시지 추출
        NSDictionary *aps = [userInfo objectForKey:@"aps"];
        // alert 추출 
        NSString *alert = [aps objectForKey:@"alert"];
        // custom 데이터 추출 
        NSString *pushSeq = [userInfo objectForKey:@"pushSeq"]; 
}

<12345678 12345678 12345678 12345678 50cfb1 3f5febbe497df>

package com.tistory.hiddenviewer.reflection.executor;

import java.lang.reflect.Method;
import com.tistory.hiddenviewer.reflection.Board;

public class GetterSetterPrinter {

	public static void main(String[] args) {
		printGettersSetters(Board.class);
	}

	public static void printGettersSetters(Class aClass){
		Method[] methods = aClass.getMethods();

		for(Method method : methods){

			if(isGetter(method)) {
				System.out.println("getter: " + method);
			} 

			if(isSetter(method)) {
				System.out.println("setter: " + method);
			}
		} // for
	}
	

	public static boolean isGetter(Method method){
		// get 으로 시작하지 않으면 반환
		if(!method.getName().startsWith("get")) {
			return false;
		}
		// 파라미터가 있으면 반환 
		if(method.getParameterTypes().length != 0) {
			return false;  
		}
		// 반환값이 없으면 반환
		if(void.class.equals(method.getReturnType())) {
			return false;
		}
		return true;
	}
	public static boolean isSetter(Method method){
		// set 으로 시작하지 않으면 반환 
		if(!method.getName().startsWith("set")) {
			return false;
		}
		// 파라미터가 개수가 1이 아니면 반환 
		if(method.getParameterTypes().length != 1) {
			return false;
		}
		return true;
	}
}

// 생성자 목록 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Constructor[] constructors = aClass.getConstructors();

// 특정 파라미터를 갖는 생성자 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Constructor constructor =
        aClass.getConstructor(new Class[]{String.class});

// 생성자의 파라미터 타입목록 얻기
Class aClass = ... // 이전에 얻은 클래스 객체
Class[] parameterTypes = constructor.getParameterTypes();

// 하나의 String 파라미터를 갖는 생성자를 얻는다. 
Constructor constructor = MyObject.class.getConstructor(String.class);
// 생성 
MyObject myObject = (MyObject)constructor.newInstance("constructor-arg1");

// 클래스에 선언된 public 속성의 Field 객체얻기
Class aClass = ... // 이전에 얻은 클래스 객체
Field[] fields = aClass.getFields();

public class MyObject{
  public String someField = null;
}

// Field 이름 얻기
Field field = ... // Field 객체를 얻는다. 
String fieldName = field.getName();

// Field 타입 얻기 
Field field = aClass.getField("someField");
Object fieldType = field.getType();

// Field 값 설정하고 조회하기
Class  aClass = MyObject.class
Field field = aClass.getField("someField");
MyObject objectInstance = new MyObject();
Object value = field.get(objectInstance);
field.set(objetInstance, value);

Board board = new Board();
board.setContents("test contents...");
		
Field field = cls.getDeclaredField("contents");
field.setAccessible(true);
String contents = (String) field.get(board);
		
System.out.println("Private Contents Field: " + contents);

// Method 객체목록 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method[] methods = aClass.getMethods();

// 파라미터를 갖는 메소드의 Method 객체 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method method = aClass.getMethod("doSomething", new Class[]{String.class});

// 파라미터가 없는 메서드의 Method 객체 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method method = aClass.getMethod("doSomething", null);

// 메서드의 파라미터 타입목록 얻기 
Method method = ... //
Class[] parameterTypes = method.getParameterTypes();

// 메서드의 반환값 타입 얻기 
Method method = ... //
Class returnType = method.getReturnType();

// 메서드 호출 
Method method = MyObject.class.getMethod("doSomething", String.class);
Object returnValue = method.invoke(null, "parameter-value1");

ClassName
Class Modifiers (public, private, synchronized 등)
Package Info
Superclass
Implemented Interfaces
Constructors
Methods
Fields
Annotations

 Class myObjectClass = MyObject.class

String className =  ... // 클래스 풀네임 
Class myObjectClass = Class.forName(className); 

// 클래스 풀네임 
Class aClass = ... // 이전에 얻은 클래스 객체 
String className = aClass.getName();

// 클래스 심플 네임 
Class  aClass = ... // 이전에 얻은 클래스 객체
String simpleClassName = aClass.getSimpleName();

// 변경자 얻기 
Class  aClass = ... // 이전에 얻은 클래스 객체
int modifiers = aClass.getModifiers();

 

// 변경자 플래그 확인 메소드들
 Modifier.isAbstract(int modifiers)
 Modifier.isFinal(int modifiers)
 Modifier.isInterface(int modifiers)
 Modifier.isNative(int modifiers)
 Modifier.isPrivate(int modifiers)
 Modifier.isProtected(int modifiers)
 Modifier.isPublic(int modifiers)
 Modifier.isStatic(int modifiers)
 Modifier.isStrict(int modifiers)
 Modifier.isSynchronized(int modifiers)
 Modifier.isTransient(int modifiers)
 Modifier.isVolatile(int modifiers)

// 패키지 정보 얻기
Class  aClass = ... // 이전에 얻은 클래스 객체
Package package = aClass.getPackage();

// 수퍼 클래스의 class 객체 얻기 
Class superclass = aClass.getSuperclass();

// 구현한 인터페이스 목록 얻기 
Class  aClass = ... // 이전에 얻은 클래스 객체
Class[] interfaces = aClass.getInterfaces();

// 클래스 생성자 목록 얻기 
Constructor[] constructors = aClass.getConstructors();

// 메소드 목록 얻기 
Method[] methods = aClass.getMethods();

// 필드 목록 얻기 
 Field[] fields = aClass.getFields();

// 어노테이션 목록 얻기
Annotation[] annotations = aClass.getAnnotations();

package com.tistory.hiddenviewer.reflection;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class Board implements ActionListener{

	public final static String boardName = "MyBoard"; 
	public ArrayList boardList;
	
	public int seq;
	protected String title;
	private String contents;
	
	public Board() {
		this(10);
	}
	
	public Board(int count) {
		this.boardList = new ArrayList(count);
	}
	
	
	public int getSeq() {
		return seq;
	}

	public void setSeq(int seq) {
		this.seq = seq;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getContents() {
		return contents;
	}

	public void setContents(String contents) {
		this.contents = contents;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		
	}

}

package com.tistory.hiddenviewer.reflection.executor;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class BoardReflectionExecutor {


	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		System.out.print("생성할 클래스 이름을 입력하세요(패키지 포함): ");
		String className = br.readLine();
		
		Class cls = Class.forName(className);
		
		// 클래스 이름얻기 
		String classFullName = cls.getName();
		String classSimpleName = cls.getSimpleName();
		
		System.out.println("class full name: " + classFullName);
		System.out.println("class simple name: " + classSimpleName);
		
		// 변경자 얻기 
		int modifiers = cls.getModifiers();
		
		if (Modifier.isPublic(modifiers)) {
			System.out.println("class is public class");
		} 
		if (Modifier.isFinal(modifiers)) {
			System.out.println("class is final class");
		}

		// 패키지 얻기 
		Package pkg = cls.getPackage();
		System.out.println("package name: " + pkg.getName());
		
		
		// 수퍼클래스 얻기 
		Class superCls = cls.getSuperclass();
		System.out.println("super class name :" + superCls.getName());
		
		
		// 구현 인터페이스 목록 얻기 
		Class[] interfaces = cls.getInterfaces();
		for (Class cs : interfaces) {
			System.out.println("this class implements " + cs.getName() + " interface");
		}
		
		// 생성자 목록 얻기 
		Constructor[] conturctors = cls.getConstructors();
		for (Constructor constructor : conturctors) {
			System.out.println("Constructor: " + constructor.getName());
		}
		
		// 메서드 목록 얻기 
		Method[] methods = cls.getMethods();
		for (Method method : methods) {
			System.out.println(method.getReturnType() + " " + method.getName() + "(...)");
		}
		
		
		// 프로퍼티 목록 얻기 
		Field[] fields = cls.getFields();
		for (Field field : fields) {
			System.out.println(field.getType() + " " + field.getName());
		}
		
	
		// 어노테이션 얻기 
		Annotation[] annotations = cls.getAnnotations();
		for (Annotation annotation : annotations) {
			System.out.println(annotation.toString());
		}
		
	}

}