반응형
반응형

 

package com.company.aa.indexing;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class test {

	public static void main(String[] args) throws IOException {

		
		// ------------------------1. 텍스트 파일을 한글자씩 읽어 리턴 ---------------------

		FileReader reader = new FileReader("D:\\file.txt");
		int ch;
		while ((ch = reader.read()) != -1) {
			System.out.print((char) ch);
		}
		
		// ------------------------2. 텍스트 파일을 한 줄씩 읽어서 리턴 ---------------------
		// 인코딩 지정 가능 
		// BufferedReader reader2 = new BufferedReader(new FileReader("d:\\file.txt", Charset.forName("UTF-8")));
		BufferedReader reader2 = new BufferedReader(new FileReader("d:\\file.txt"));
		String str;
		while ((str = reader2.readLine()) != null) {
			System.out.println(str);
		}
		reader2.close();
		
		// ------------------------3. File 클래스 이용 ---------------------
		
		List<String> lines = Files.readAllLines(Paths.get("d:\\file.txt"));
		System.out.println(lines);
		
		// ------------------------3-1. File 클래스 이용 ---------------------
		byte[] bytes = Files.readAllBytes(Paths.get("d:\\file.txt"));
		System.out.println(new String(bytes));
		
		// ------------------------3-2. File 클래스 이용 ---------------------
		String str2 = Files.readString(Paths.get("d:\\file.txt"));
		System.out.println(str2);
		
	}

}
반응형
반응형
package com.lsj.chatting;

import org.json.JSONArray;
import org.json.JSONObject;

public class testing {

	public static void main(String[] args) {


		/** JSONObject (no data) **/
		JSONObject json = new JSONObject();
		
		System.out.println("jsonFormat : " + json);
		
		/** 이름 넣기 **/
		json.put("name", "Lee");
		
		System.out.println("jsonName : " + json);
		System.out.println("name : " + json.getString("name"));
		
		/** JSONArray (취미) **/
		JSONArray hobbies = new JSONArray();

		hobbies.put("soccer");
		hobbies.put("basket ball");
		json.put("hobbies", hobbies);
		
		System.out.println("jsonNameHobbies : " + json);
		System.out.println("jsonHobbies : " + json.getJSONArray("hobbies"));

		
		/** 취미 + 이름 데이터 배열에 입력 **/
		JSONArray people = new JSONArray();
		people.put(json);
		
		/** 키에 해당하는 값이 어떤 타입이냐에 따라 get 뒤에 붙는게 정해진다. **/

		/** 이름 넣기 **/
		json = new JSONObject(); // 초기화
		json.put("name", "Tom");
		

		/** JSONArray (취미) **/
		hobbies = new JSONArray(); // 초기화
		hobbies.put("painting");
		hobbies.put("weight training");
		json.put("hobbies", hobbies);
		
		people.put(json);
		
		System.out.println("people : " + people);
		
		/** 최종 JSON **/
		JSONObject person = new JSONObject();
		person.put("members", people);

		System.out.println("person : " + person);
		
		/** 사람 출력 **/
		JSONArray members = person.getJSONArray("members");
		JSONObject member0 = members.getJSONObject(0);
		JSONObject member1 = members.getJSONObject(1);
		
		System.out.println("member0 : " + member0);
		System.out.println("member1 : " + member1);
		
		/** 취미 출력 **/
		JSONArray member0Hobbies = member0.getJSONArray("hobbies");
		System.out.println("member0Hobbies : " + member0Hobbies);
		
		String member0Hobbie = member0Hobbies.getString(0);
		System.out.println("member0Hobbie : " + member0Hobbie);
		
		member0Hobbie = (String) member0Hobbies.get(1);
		System.out.println("member0Hobbie : " + member0Hobbie);
		// person : {"members":[{"hobbies":["soccer","basket ball"],"name":"Lee"},{"hobbies":["painting","weight training"],"name":"Tom"}]}
        // 일반적 JSON 구조
	}
	
}
반응형
반응형

📝변수명 짓는데 도움 되는 사이트 

https://www.curioustore.com/#!/

 

Curioustore

변수명 짓기, 컬럼명 짓기, 영어약자, 変数名 つけ方, カラム名建てる, 英語の略語, 命名变量, 命名该列, 英文缩写

www.curioustore.com

 

📝URL 인코딩 디코딩 사이트

https://www.convertstring.com/ko/EncodeDecode/UrlDecode

 

URL 디코드 - 온라인 URL 디코더

 

www.convertstring.com

 

📝Json 재정렬 사이트

http://json.parser.online.fr/

 

Json Parser Online

 

json.parser.online.fr

https://jsonformatter.curiousconcept.com/#

 

JSON Formatter & Validator

Format and validate JSON data so that it can easily be read by human beings.

jsonformatter.curiousconcept.com

 

📝JSON To SQL

https://www.convertjson.com/json-to-sql.htm

 

JSON To SQL Converter

 

www.convertjson.com

 

📝NLP [ChatGPT, Bing]

https://chat.openai.com/

https://www.bing.com/

 

Info

Stretching nearly 100 kilometres, the Verdon Gorge

www.bing.com

 

반응형
반응형

📝논리명

테이블의 컬럼의 별칭 → 한글이나 알아보기 쉬운 단어로 표현

예) "price" 컬럼의 논리명은 "가격"이다

 

📝물리명

DB 테이블의 실제 컬럼명

예) "price" 컬럼의 물리명은 "price"이다

 

📝DDL (Data Definition Language)

테이블과 같은 스키마 구조를 정의하는 명령어 (CREATE, ALTER, DROP 등..)

 

📝DML(Data Manipulation Language)

Data를 활용하기 위한 언어 (INSERT, DELETE, UPDATE, SELECT)

 

📝데이터 무결성

데이터베이스에서 데이터의 정확성, 일관성, 유효성이 유지되는 것을 의미한다

무결성 설계를 하지 않으면 테이블에 중복 데이터 존재 및 부모 자식 데이터간의 논리적 관계 깨짐 등에 대한 문제가 발생할 것입니다 → 필수는 아니지만 모든 걸 지키는게 좋다

 

  • 개체 무결성
    • 기본키에는 Null이 올 수 없고 하나의 값만 존재해야한다
  • 참조 무결성
    • 테이블간 참조 관계 선언하는 조건으로 외래키는 Null이 아니여야하고 참조 릴레이션의 기본키 값과 동일해야한다
  • 도메인 무결성
    • 특정 필드의 무결성 보장하기 위한 것으로 필드 타입, Null 허용에 대한 설정을 올바르게 하는 것 → 주민등록번호에 글자가 들어가면 안 됨
  • Null 무결성
    • 테이블 특정 속성 값이 Null이 될 수 없게 하는 조건
  • 고유 무결성
    • 특정 속성에 대해 각 레코드들이 갖는 값들이 서로 달라야한다 → 중복된 레코드가 있으면 안 된다
  • 키 무결성
    • 하나의 테이블에는 적어도 하나의 키가 존재해야한다
  • 관계 무결성
    • 참조 무결성 및 부모 테이블과 자식 테이블 간의 관계가 올바르게 설정되었는지에 대한 것

 

📝Database Schema

Data Model을 바탕으로 Database의 구조를 기술한 것 → 테이블 명, 컬럼명, 타입 등...

 

📝이스케이프 문자

특별한 문자를 입력하기 위해 백슬래쉬(\)를 붙이는 문자를 말한다.

 

  • \\
    • 백슬래시
  • \r
    • 캐리지리턴 (커서의 위치를 현재 줄의 맨 앞으로 이동)
  • \'
    • 작은 따옴표
  • \"
    • 큰 따옴표
  • \t
  • \n
    • 개행
  • \r\n
    • Enter  → 타자기를 보면 오른쪽으로 쭉 쳐지다가 왼쪽로 간 후 개행이 된다 그걸 토대로 만들어진게 Enter이다.

 

 

📝정규표현식

정규표현식은 문자열을 처리하는 방법 중의 하나 특정한 조건의 문자를 '검색'하거나 '치환'하는 과정을 매우 간편하게 처리 할 수 있도록 하는 수단입니다.

 

정규식에서 물음표(?), 마침표(.), 별표(*), 백슬래쉬(\) 문자는, 정규식 자체를 형성하는 특수문자이기에, 이 문자들 자체를 있는 그대로 매치시키려면 \이라는 이스케이프 문자를 붙여야 합니다.

 

노트패드에서 정규표현식으로 활용한 예입니다 아마도 리눅스의 경우 정규표현식이 사용되는 경우가 많은 거 같습니다

 

🔗 참고 및 출처

https://cocoon1787.tistory.com/778

반응형
반응형

Chart.js에서 사용하는 차트들을 ajax로 비동기 통신시에 넘어온 값들로 차트를 재구성할 때

그 이전에 데이터들이 남아있는 문제가 발생한다.

 

이걸 해결 하기 위해서는 ajax로 호출 할 때마다 Chart.js를 붙히는 곳의 태그를 없애고 다시 만들어주는 과정을 추가해줘야 한다.

 

예) data : [12, 19, 3, 5, 2, 3] 의 값들이 남아있는 문제가 발생 [ 그래프에 호버시 값이 남아있는 걸 확인 ]

<canvas id="myChart" width="400" height="400"></canvas>
<script>
$(function () {
    var ctx = document.getElementById("myChart").getContext('2d');
    var myChart = new Chart(ctx, {
        type: 'bar',
        data: {
            labels: ["Red", "Blue", "Yellow", "Green", "Purple", "Orange"],
            datasets: [{
                label: '# of Votes',
                data: [12, 19, 3, 5, 2, 3],
                backgroundColor: [
                    'rgba(255, 99, 132, 0.2)',
                    'rgba(54, 162, 235, 0.2)',
                    'rgba(255, 206, 86, 0.2)',
                    'rgba(75, 192, 192, 0.2)',
                    'rgba(153, 102, 255, 0.2)',
                    'rgba(255, 159, 64, 0.2)'
                ],
                borderColor: [
                    'rgba(255,99,132,1)',
                    'rgba(54, 162, 235, 1)',
                    'rgba(255, 206, 86, 1)',
                    'rgba(75, 192, 192, 1)',
                    'rgba(153, 102, 255, 1)',
                    'rgba(255, 159, 64, 1)'
                ],
                borderWidth: 1
            }]
        },
        options: {
            scales: {
                yAxes: [{
                    ticks: {
                        beginAtZero:true
                    }
                }]
            }
        }
    });
});
</script>

 

 

 

반응형
반응형

공통

  • 자바는 기본적으로 카멜케이스를 따른다.
  • 통상적으로 자주 사용하는 약어는 사용해도 좋지만 약어 사전에 등록을 해놓아 다른 사람과 충돌이 안 생기게 한다.[ 이건 다들 작업을 시작 하기전에 미리 정의해야 할 사항 ]
  • 협업자와 함께 개발을 하는 경우에는 이름을 통해 그것이 무엇인지 나타내야 한다.
  • 로직이 끝나면 한 줄을 띄어준다 (보기 편하게 하는데 의의가 있음 너무 남발해도 좋지 않다.)
    def get_librosa_mfcc(filepath, n_mfcc = 40, del_silence = False, input_reverse = True):
        if filepath.split('.')[-1] == 'pcm':
            pcm = np.memmap(filepath, dtype='h', mode='r')
            sig = np.array([float(x) for x in pcm])
        elif filepath.split('.')[-1] == 'wav':
            sig, _ = librosa.core.load(filepath, sr=16000)
        else:
            raise ValueError("Invalid format !!")
        if del_silence:
            non_silence_ids = librosa.effects.split(sig, top_db=30)
            sig = np.concatenate([sig[start:end] for start, end in non_silence_ids])
        mfcc = librosa.feature.mfcc(sig, sr=16000, hop_length=160, n_mfcc=n_mfcc, n_fft=400, window='hamming')
        if input_reverse:
            mfcc = mfcc[:,::-1]
        return torch.FloatTensor( np.ascontiguousarray( np.swapaxes(mfcc, 0, 1) ) )​

 → 못된 사례

def get_librosa_mfcc(filepath, n_mfcc = 40, del_silence = False, input_reverse = True):
    if filepath.split('.')[-1] == 'pcm':
        pcm = np.memmap(filepath, dtype='h', mode='r')
        sig = np.array([float(x) for x in pcm])

    elif filepath.split('.')[-1] == 'wav':
        sig, _ = librosa.core.load(filepath, sr=16000)

    else:
        raise ValueError("Invalid format !!")

    if del_silence:
        non_silence_ids = librosa.effects.split(sig, top_db=30)
        sig = np.concatenate([sig[start:end] for start, end in non_silence_ids])

    mfcc = librosa.feature.mfcc(sig, sr=16000, hop_length=160, n_mfcc=n_mfcc, n_fft=400, window='hamming')

    if input_reverse:
        mfcc = mfcc[:,::-1]

    return torch.FloatTensor( np.ascontiguousarray( np.swapaxes(mfcc, 0, 1) ) )

 → 잘된 사례

 

 

클래스

  • 동사를 넣지 않는다.
  • 명사나 명사구로 작성한다.

 

메소드

  • 동사로 시작한다.
  • 카멜케이스 규정을 따른다.
  • 어떤 행동을 하는지에 대한 내용이 있어야한다.
  • 함수는 하나의 동작만 해야한다. → printBankName(String bankName)

 

 

변수명

  • 전치사를 최대한 생략한다. [ to는 자주 쓰이므로 괜찮다 ]
  • 굳이 관사를 넣지 않는다.
  • 단수와 복수를 구분한다
  • 상수는 모두 대문자 표시
  • 변수명이 길어지더라도 정확한 의미를 내포해야한다.
  • 동사를 넣지 않는다.
  • List와 같은 배열 타입일 경우 복수형으로 표시한다. → ArrayList<String> item(x) ArrayList<String> items(o)

 

Bool [참고]

  • isExecuting (실행 중인가?)
  • isShinhanBank (신한은행인가?)
  • isEditable (수정할 수 있는가?)
  • hasVideo (비디오를 가지고 있는가?)
  • canBecomeFirstResponder (첫번째 응답자가 될 수 있는가?)
  • shouldReinstallProduct (제품을 재설치해야 하는가?)
  • allowedAccess (허용된 엑세스인가?)

상수

  • 상수는 대문자로 표시한다 →  int MAIN_WIDTH = 1024

 

 

자바 메소드와 클래스명 주석 팁

@method  : 메소드명 or 클래스명
@brief      : 함수 or 클래스 설명
@detail     : 함수 or 클래스 상세 설명
@author   : 작성자
@since     : 작성일자
@param   : 인자(매개변수)
@return   : 반환값
@why      : 만든 이유

 

 

Interface 팁

1. 함수의 확장성(교체성)이 있다면 Interface로 만든다

   예) 피자 : 5000원, 햄버거 : 50000원 → 피자    5000

                                                    햄버거  50000   [출력기준이 바뀔 수 있는 경우]

 

2. 동일한 함수기능이(내용물은 살짝 달라도 동일한 기능) 여러 클래스에서 쓰이는 경우 Interface로 구성한다.

if (bank.equals("KB")){
  for(int i = 0 ; i < 10; i++){
    if()
  }
}else if (bank.equals("NH"){
  for(int i = 0 ; i < 10; i++){
    if()
  }
}else if (bank.equals("SH"){
  for(int i = 0 ; i < 10; i++){
    if()
  }
}

→  이런식이면 엄청 복잡하다

 

 

첫번째 if문, 두번째 else if , 세번째 else if
→  동일한 부분을 interface로 만든다.

interface BankImpl{
  public void print();
}

class KB{
    @Override
    public void printBankName() {
        System.out.println("KB!!");
    }
}

class NH{
    @Override
    public void printBankName() {
        System.out.println("KB!!");
    }
}

class SH{
    @Override
    public void printBankName() {
        System.out.println("KB!!");
    }
}
    Map<String, Alphabet> typeMap = new HashMap<>();

    typeMap.put("KB", new KB());
    typeMap.put("NH", new NH());
    typeMap.put("SH", new SH());

    String type = "NH";

    typeMap.get(type).printBankName();

이럴경우 들어온 값에 따라 은행이름을 출력하는구나 간단하게 알 수 있다.

 

 

 

 

반응형
반응형

📝body 데이터 받기 (Servlet)

@RequestMapping(value = "/post.do", method = RequestMethod.POST)
public void post(HttpServletRequest request, HttpServletResponse response) throws IOException {
	
    // 한번만 호출 가능 (분석 안 해서 왜 그런지는 모름)
	String body = getBody(request);
    System.out.println(body);
    JSONObject obj = new JSONObject(body);

    System.out.println(obj.get("searchWord"));
    System.out.println(obj.get("pageNum"));

    response.setContentType("application/json; charset=UTF-8");
    PrintWriter writer = null;

    writer = response.getWriter();
    writer.print(obj);
    writer.flush();
}

public static String getBody(HttpServletRequest request) throws IOException {

    String body = null;
    StringBuilder stringBuilder = new StringBuilder();
    BufferedReader bufferedReader = null;

    try {
        InputStream inputStream = request.getInputStream();
        if (inputStream != null) {
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"UTF-8"));
            char[] charBuffer = new char[128];
            int bytesRead = -1;
            while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                stringBuilder.append(charBuffer, 0, bytesRead);
            }
        }
    } catch (IOException ex) {
        throw ex;
    } finally {
        if (bufferedReader != null) {
            try {
                bufferedReader.close();
            } catch (IOException ex) {
                throw ex;
            }
        }
    }

    body = stringBuilder.toString();
    return body;
}

출처 : https://kwonyang.tistory.com/2

 

📝body 데이터 받기 (requestBody) [HashMap]

package com.lsj.spring_study;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.json.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * Handles requests for the application home page.
 */
@Controller
public class HomeController {
	final static Logger logger = LogManager.getLogger(HomeController.class);
	final static Logger APIParamLogger = LogManager.getLogger("AS_API_PARAM");
	
	@RequestMapping(value = "/getLogs.do", method = RequestMethod.GET)
	public void logs() {

		
		APIParamLogger.error("TRACE TEST");
        logger.info("INFO TEST");
        logger.debug("DEBUG TEST");
        logger.warn("WARN TEST");
        logger.error("ERROR TEST");
        logger.fatal("FATAL TEST");
        System.out.println(logger.getLevel());
        System.out.println(logger.getLevel().intLevel());		
//		Logger APIParamLogger = LogManager.getLogger("AS_API_PARAM");
//		APIParamLogger.info("abc");
		
		
	}
	
	
	/** params **/
	@RequestMapping(value = "/params.do", method = RequestMethod.POST)
	public void params(String code,String name) {

		// 호출 Url      : localhost:8080/jsonToObject.do?name=hello&age=20e
		// Content-Type : params
		// Header 		:  key → name, Value → hello 
		// Header 		:  key → age, Value → 20
		
		System.out.println(">>> " + code); // null
		System.out.println(">>> " + name); // Lee
		
		/** 일반적으로 POST 방식에 쿼리스트링을 붙히지 않지만 붙혀도 인식이 가능하다. **/
	}

	/** params **/
	@RequestMapping(value = "/paramsToObject.do", method = RequestMethod.POST)
	public void paramsToObject(BodyVO bodyVO) {

		// 호출 Url      : localhost:8080/jsonToObject.do?name=hello&age=20e
		// Content-Type : params
		// Header 		:  key → name, Value → hello 
		// Header 		:  key → age, Value → 20
		
		System.out.println(">>> " + bodyVO.getName()); // hello
		System.out.println(">>> " + bodyVO.getAge()); // 20
		
		/** 일반적으로 POST 방식에 쿼리스트링을 붙히지 않지만 붙혀도 인식이 가능하다. **/
	}
	

	
	
	/** application/x-www-form-urlencoded **/
	@RequestMapping(value = "/urlencoded.do", method = RequestMethod.POST)
	public void urlencoded(String code,String name) {

		// 호출 Url      : urlencoded.do?name=Lee
		// Content-Type : application/x-www-form-urlencoded
		// Body 		:  key → code, Value → ABC 
		//    			   key → name, Value → Lee
		
		System.out.println(">>> " + code); // ABC
		System.out.println(">>> " + name); // Lee 
		
		// 일반적으로 POST 방식에 쿼리스트링을 붙히지 않지만 붙혀도 인식이 가능함
		// x-www-form-urlencoded 의 경우 쿼리스트링처럼 code=ABC 인식을 한다.
	}
	
	/** application/x-www-form-urlencoded **/
	@RequestMapping(value = "/urlencodedToObject.do", method = RequestMethod.POST)
	public void urlencodedToObject(BodyVO bodyVO) {
		
		// 호출 Url      : urlencoded.do
		// Content-Type : application/x-www-form-urlencoded
		//    			   key → name, Value → Lee
		// Body 		:  key → age, Value → 20 
		
		System.out.println(">>> " + bodyVO.getName()); // Lee
		System.out.println(">>> " + bodyVO.getAge()); // 20
	}
	
	/** application/x-www-form-urlencoded의 경우 따로 RequestBody가 필요없다. 동작방식이 GET의 Header와 동일한 것 같다 **/
	
	
	/** 이 밑에의 MIME 타입은 반드시 RquestBody를 사용해서 값을 받을 수 있다. **/
	/** text **/
	@RequestMapping(value = "/text.do", method = RequestMethod.POST)
	public void text(@RequestBody String bodyContents) {

		// 호출 Url      : text.do
		// body 		: this is text
		// Content-Type : text 또는 text/html
		System.out.println(">>> " + bodyContents); // this is text
		
	}
	
	
	/** application/json **/
	@RequestMapping(value = "/json.do", method = RequestMethod.POST)
	public void json(@RequestBody String bodyContents) {

		// 호출 Url      : json.do
		// body 		: {"content" : "this is json"}
		// Content-Type : application/json
		System.out.println(">>> " + bodyContents); // {"content" : "this is json"}
		
	}
	
	/** application/json (Object Injection) **/
	@RequestMapping(value = "/jsonToHashMap.do", method = RequestMethod.POST)
	public @ResponseBody HashMap<String, Object> jsonToObject(@RequestBody HashMap<String, Object> bodyVO) {

		/** BodyVO (HashMap도 또한 Object이기 떄문에 동일하게 적용 된다. **/
		// String name
		// String age → int 형으로 값을 보내면 못 자동 Injection이 안 된다. "age" : 20 (X)
		
		/** 참고로 BodyVO에 default값이 설정되어 있어도 ReuqestBody에 넘어온 값이 없다면(body에 json을 안 보내면) null로 덮어씌워진다. **/
		/** 필요사항에서는 데이터를 까서 검증하는 작업을 직접해야할 거 같다. **/
		
		// 호출 Url      : jsonToObject.do
		// body 		: {"name" : "lee", "age":"20"}
		// Content-Type : application/json
		
		System.out.println(bodyVO); // {name=lee, age=20}
		
		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("bodyVO", bodyVO);
		
		return map;
	}
	
	
	/** application/json (Object Injection) **/
	@RequestMapping(value = "/jsonToObject.do", method = RequestMethod.POST)
	public @ResponseBody HashMap<String, Object> jsonToObject(@RequestBody BodyVO bodyVO) {

		/** BodyVO (HashMap도 또한 Object이기 떄문에 동일하게 적용 된다. **/
		// String name
		// String age → int 형으로 값을 보내면 못 자동 Injection이 안 된다. "age" : 20 (X)
		
		/** 참고로 BodyVO에 default값이 설정되어 있어도 ReuqestBody에 넘어온 값이 없다면(body에 json을 안 보내면) null로 덮어씌워진다. **/
		/** 필요사항에서는 데이터를 까서 검증하는 작업을 직접해야할 거 같다. **/
		
		// 호출 Url      : jsonToObject.do
		// body 		: {"name" : "lee", "age":"20"}
		// Content-Type : application/json
		System.out.println(">>> " + bodyVO.getName()); // lee
		System.out.println(">>> " + bodyVO.getAge()); // 20
		
		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("bodyVO", bodyVO);
		
		return map;
	}
	
	/**
	 * jsonToObject.do을 사용하기 위해서는 하기 라이브러리가 필요 (body 내용을 Object에 Injeciton)
	 * 없어도 주입이 되는 것처럼 보이지만 4번에 한번씩 에러를 뱉는 현상 발견
	<dependency>
		<groupId>com.fasterxml.jackson.core</groupId>
		<artifactId>jackson-databind</artifactId>
		<version>2.9.3</version>
	</dependency>
	
	<dependency>
		<groupId>org.codehaus.jackson</groupId>
		<artifactId>jackson-mapper-asl</artifactId>
		<version>1.9.13</version>
	</dependency>
	**/
	
	
	
	
	
	
	
	/** responseBody란 처리한 결과를 클라이언트에게 다시 돌려줘서 읽을 수 있게한다. (즉 return 값이 있어야한다.) **/
	// 미사용시 → 404 페이지를 찾을 수 없음
	// 사용시 → {"bodyVO" : {"name" : "lee", "age":"20"}}
	

}
  • RequestBody를 이용해 body에 내용을 읽을 수 있다.
  • 주의) 라이브러리 필요  → 전자정부의 경우 dispatcher에 추가 작업 해야함 

 

<dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-mapper-asl</artifactId>
    <version>1.9.13</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.3</version>
</dependency>

 

📝POST방식 통신 (return JSONObject)

StringBuffer response;
// map은 body에 담아서 보낼 데이터가 존재할 때 사용 (일반적 json으로 많이 보내서 적음)
public JSONObject getConnection(String uri, HashMap<String,Object> map) {
    StringBuilder sb = null;

    HttpURLConnection conn = null;
    JSONObject responseJson = null;

    try {
        URL url = new URL(uri);

        conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(5000);
        conn.setReadTimeout(5000);
        conn.setRequestMethod("POST");
        conn.setDoInput(true);
        conn.setDoOutput(true);
        conn.setRequestProperty("Content-Type", "application/json");



        System.out.println(map);
/*			
        // body에 json 데이터 담아서 request 할때 사용
        JSONObject obj = new JSONObject(map);

        try (OutputStream os = conn.getOutputStream()){
            byte request_data[] = obj.toString().getBytes("utf-8");
            os.write(request_data);
            os.close();
        }			
*/

        int responseCode = conn.getResponseCode();
        if (responseCode == 400 || responseCode == 401 || responseCode == 500) {
            System.out.println(responseCode + " Error!");
        } else {
            BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
            sb = new StringBuilder();
            String line = "";
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            responseJson = new JSONObject(sb.toString());
            // System.out.println(responseJson);

            return responseJson;
        }
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSONException e) {
        System.out.println("not JSON Format response");
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return responseJson;
}

 

 

📝Get방식 통신 (return JSONObject)

public JSONObject getConnection(String uri) {
    StringBuilder sb = null;

    HttpURLConnection conn = null;
    JSONObject responseJson = null;

    try {
        URL url = new URL(uri);

        conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(5000);
        conn.setReadTimeout(5000);
        conn.setRequestMethod("GET");
        // conn.setDoOutput(true);

        JSONObject commands = new JSONObject();

        int responseCode = conn.getResponseCode();
        if (responseCode == 400 || responseCode == 401 || responseCode == 500) {
            System.out.println(responseCode + " Error!");
        } else {
            BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
            sb = new StringBuilder();
            String line = "";
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            responseJson = new JSONObject(sb.toString());
            // System.out.println(responseJson);

            return responseJson;
        }
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSONException e) {
        System.out.println("not JSON Format response");
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return responseJson;
}

 

📝Get방식 통신 (return String)

StringBuffer response;
public String callGetMethod(String url) {		


    try {

        // 통신 주소  등록
        URL obj = new URL(url);

        // 통신 방식 설정
        HttpURLConnection conn = (HttpURLConnection) obj.openConnection();
        conn.setRequestProperty("Content-Type", "application/json; charset=utf-8" );
        conn.setDoOutput(true);
        conn.setRequestMethod("GET");

        // ---- 읽어온 데이터를 담기 ----
        BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));

        String inputLine;
        response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

    } catch (Exception e) {
        e.printStackTrace();
    }

    // ---- 읽어온 데이터를 반환 ----
    String responseData =response.toString();
    return responseData; 
}

conn.setRequestProperty만 주의해서 작성 나머진 그대로 활용 가능 → application/json; charset-utf-8

 

📝Delete 방식 통신

public void callDeleteMethod(String url) {

    URL obj;
    try {
        obj = new URL(url);

        HttpURLConnection httpCon = (HttpURLConnection) obj.openConnection();
        httpCon.setDoOutput(true);
        httpCon.setRequestMethod("DELETE");
        httpCon.connect();

        int responseCode = httpCon.getResponseCode();
        // connect만 해서 끝이 아니라 무조건 어떤 행동을 해야 위에 동작이 진행된다.

    } catch (Exception e) {
        e.printStackTrace();
    }
}
반응형
반응형

레드헷/우분투 계열에서는 /etc/hosts 파일을 우선적으로 참고하여, 네임서버를 아이피주소로 바꿉니다.

이거처럼 127.0.0.1을 locahost로 쓰겠다는 것입니다.

 

반응형
반응형

📝정형데이터

그 값이 의미를 파악하기 쉽고 규칙적인 값(단어, 숫자 등)이 들어간 데이터를 의미합니다.

예) 짬뽕, 1200 등...

 

📝비정형데이터

정해진 규칙이 없어서 값의 의미를 쉽게 파악하기 힘든 데이터를 의미합니다 → 텍스트, 음성, 영상과 같은 데이터

예) 짬뽕은 맛있다, 영상, 음성 등..

 

📝반정형데이터

일정한 구조를 가지고 있지만 모든 데이터가 엄격한 규칙을 따르지 않습니다XML, HTML, JSON

예) {"result" : "ok"} 등...

 

📝하이브리드 앱

하이브리드 앱은 네이티브 앱과 웹앱의 결합 형태네이티브 기술이 필요한 곳은 네이티브로 그렇지 않고 웹으로도 충분히 가능하다면 웹뷰를 이용해 웹과 연결 시킵니다 이를 통해 네이티브 API와 브라우저 API를 모두 사용할 수 있는 장점이 있습니다

JavaScript Interface라는 걸 이용해 JavaScript가 네이티브 코드의 특정 함수를 호출할 수 있게 합니다 → 비슷한 기술을 쓰는 React Native라는 프레임워크가 존재합니다

 

💗장점

  • 네이티브 API와 브라우저 API를 이용한 다양한 개발 가능 웹 개발 기술로 앱을 개발 가능
  • 한번의 개발로 다수의 플랫폼 대응 가능

⚠️단점

  • 웹뷰에서 앱을 실행할 경우 앱의 성능이 브라우저의 성능

 

📝네이티브 앱

모바일 기기에 최적화 된 언어로 개발 된 앱으로 안드로이드는 Java나 코틀린, IOS는 스위프트로 만드는 것을 의미합니다.

 

💗장점

  • 성능이 웹앱, 하이브리드 앱에 비하여 가장 높습니다
  • 네이티브 API를 호출하여 사용해 플랫폼과 밀착되어 있습니다 → 위치, 핸드폰 기울기 정도 등을 이용할 수 있습니다

⚠️단점

  • 플랫폼에 한정적입니다
  • 플랫폼에서 요구하는 언어에 제약적입니다 따라서 플랫폼의 API를 다루는데 익숙해야 합니다.

 

📝웹앱

모바일웹과 네이티브앱을 결합 상태로 모바일 웹보다 조금 더 모바일에 최적화 된 앱 → 굳이 모바일웹하고 구분 지을 필요는 없어보임

 

📝모바일웹

PC용 홈페이지를 모바일 스크린의 크기에 맞춰 줄여 놓은 것

 

💗장점

  • 웹사이트를 보는 것이라 따로 설치가 필요 없다 모든 기기와 브라우 접근가능
  • 승인과정이나 별도 설치가 필요하지 않아 유지보수가 용이

⚠️단점

  • 플랫폼 API (카메라) 등을 사용할 수 없고 오로지 브라우저 API만 사용
  • 터치 앱 개발에는 약간 번거로움

 

반응형