redis 윈도우버전을 설치한다.

 

그뒤 cmd에서 --redis-server --port 7001 로 실행

 

그리고 아래와 같이 자바코드를 넣는다.

package com.test.redisTest;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class TestRedis {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		 String host = "127.0.0.1"; //로컬서버
	        int port = 7001;   //포트
	        int timeout = 3000;
	        int db = 0;
	        
	        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
	        
	        JedisPool pool = new JedisPool(jedisPoolConfig,host,port,timeout,null,db);
	        
	        Jedis jedis = pool.getResource();
	        
	        //Connect 체크 
	        System.out.println(jedis.isConnected());
	        
	        jedis.set("key1", "apple");
	        jedis.set("key2", "banana");
	        jedis.set("key3", "grape");
	        
	        // 데이터의 만료시간을 지정
	        jedis.expire("key5",1);
	        
	        System.out.println("key3: "+jedis.get("key3"));
	        
/*	        try {
	            Thread.sleep(3000);
	        } catch (InterruptedException e) {
	            // TODO Auto-generated catch block
	            e.printStackTrace();
	        }*/
	        System.out.println("key5: "+jedis.get("key5"));
	    
	        if( jedis != null ){
	        	System.out.println("클로즈");
	            jedis.close();
	        }
	        pool.close();
		
		
		
	        System.out.println("key6: "+jedis.get("key6"));
		
		
		
	}

}

 

그럼 결과값은

 

 

 

 

아파치의 httpcomponenet를 활용하여 http 통신 테스트를 해본다.

 

그러기 위해서는 pom.xml에 아래를 추가한다.

 

<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpclient</artifactId>
	<version>4.4</version>
</dependency>

그뒤 패키지를 만들고 그 안에 void 자바파일을 하나 만든다.

 

패키지명: com.test.httpConnection01

 

파일명: HttpConnectionTest01.java

package com.test.httpConnection01;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

public class HttpConnectionTest01 {
	
    private static final String USER_AGENT = "Mozila/5.0";
    private static final String GET_URL = "http://www.google.com";    
 
    public static void sendGet() throws ClientProtocolException, IOException {
        
        //http client 생성
        CloseableHttpClient httpClient = HttpClients.createDefault();
        
        
        //get 메서드와 URL 설정
        HttpGet httpGet = new HttpGet(GET_URL);

        //agent 정보 설정
        httpGet.addHeader("User-Agent", USER_AGENT);
        
      //get 요청
        CloseableHttpResponse httpResponse = httpClient.execute(httpGet);

        System.out.println("::GET Response Status::");
        
        //response의 status 코드 출력
        System.out.println("status code: "+httpResponse.getStatusLine().getStatusCode());
        
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                httpResponse.getEntity().getContent()));
 
        String inputLine;
        StringBuffer response = new StringBuffer();
 
        while ((inputLine = reader.readLine()) != null) {
            response.append(inputLine);
        }
        
        reader.close();
 
        //Print result
        System.out.println(response.toString());
        httpClient.close();
    }

}

 

그리고 위 메소드를 실행할 파일을 하나 만든다.

 

파일명: HttpConnectionTextExec.java

package com.test.httpConnection01;

import java.io.IOException;

import org.apache.http.client.ClientProtocolException;

public class HttpConnectionTextExec {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		try {
			//예제1 connection 테스트
			HttpConnectionTest01.sendGet();
			

			//System.out.println("==============비트코인 가격  json 시작=================");
			//예제2 비트코인가격 Json
			//HttpConnectionTest02.sendGet();
			
			
		
		} catch (ClientProtocolException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
		
		
	}

}

 

코드를 완성 한 후 실행하면 아래와 같은 결과를 얻는다.

::GET Response Status::
status code: 200
<!doctype html><html itemscope="" itemtype="http://schema.org/WebPage"

 

그런데 json을 받아오는 경우가 많으므로 json 예제파일을 하나 더 만들어보자.

 

파일명: HttpConnectionTest02

package com.test.httpConnection01;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class HttpConnectionTest02 {

	
	
	private static final String USER_AGENT = "Mozila/5.0";

	//비트코인 가격 json API 주소
    private static final String GET_URL = "https://api.blockchain.com/v3/exchange/tickers/"+
    "BTC-USD";


    
    public static void sendGet() throws ClientProtocolException, IOException {
        
        //http client 생성
        CloseableHttpClient httpClient = HttpClients.createDefault();
        
        //get 메서드와 URL 설정
        HttpGet httpGet = new HttpGet(GET_URL);
        
        //agent 정보 설정
        httpGet.addHeader("User-Agent", USER_AGENT);
        httpGet.addHeader("Content-type", "application/json");
        
        //get 요청
        CloseableHttpResponse httpResponse = httpClient.execute(httpGet);
        

       System.out.println("status code: "+httpResponse.getStatusLine().getStatusCode());
        String json = EntityUtils.toString(httpResponse.getEntity(), "UTF-8");
        
        
        
        System.out.println(json);
        
        httpClient.close();


    }
}

 

그리고 실행 파일에서 예제1에 주석을 걸고, 예제2 비트코인 가격 부분 주석을 푼다.

package com.test.httpConnection01;

import java.io.IOException;

import org.apache.http.client.ClientProtocolException;

public class HttpConnectionTextExec {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		try {
			//예제1 connection 테스트
			//HttpConnectionTest01.sendGet();
			

			System.out.println("==============비트코인 가격  json 시작=================");
			//예제2 비트코인 가격
			HttpConnectionTest02.sendGet();
			
			
		
		} catch (ClientProtocolException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
		
		
	}

}

 

그러면 결과값은 아래와 같다.

==============비트코인 가격  json 시작=================
status code: 200
{"symbol":"BTC-USD","price_24h":35775.7,"volume_24h":63.66743294,"last_trade_price":35717.4}

 

더나아가서 비트코인 가격만 나타나려고 하면 json으로 그 값을 저장하는 변수를 추가해줘야한다.

 

pom.xml에 아래와 같이 GSON 메이븐을 추가해준다. (json-simple이 아닌 gson이다.)

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.1</version>
</dependency>

 

그뒤 비트코인 가격 클래스에 json parsing 코드를 넣는다.

package com.test.httpConnection01;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;

import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class HttpConnectionTest02 {

	
	
	private static final String USER_AGENT = "Mozila/5.0";
/*    private static final String GET_URL = "https://blockchain.info/ko"
            + "/rawblock/0000000000000bae09a7a393a8acd"
            + "ed75aa67e46cb81f7acaa5ad94f9eacd103";*/
    
	//비트코인 가격 json API 주소
    private static final String GET_URL = "https://api.blockchain.com/v3/exchange/tickers/"+
    "BTC-USD";


    
    public static void sendGet() throws ClientProtocolException, IOException {
        
        //http client 생성
        CloseableHttpClient httpClient = HttpClients.createDefault();
        
        //get 메서드와 URL 설정
        HttpGet httpGet = new HttpGet(GET_URL);
        
        //agent 정보 설정
        httpGet.addHeader("User-Agent", USER_AGENT);
        httpGet.addHeader("Content-type", "application/json");
        
        //get 요청
        CloseableHttpResponse httpResponse = httpClient.execute(httpGet);
        

       System.out.println("status code: "+httpResponse.getStatusLine().getStatusCode());
        String json = EntityUtils.toString(httpResponse.getEntity(), "UTF-8");
        String sdsd="dsd";
        
        
        System.out.println(json);
        
        //Json parsing 추가
        JsonParser jsonParser= new JsonParser(); //JsonParser를 불러온다.
        JsonObject jsonObj= (JsonObject) jsonParser.parse(json); //json을 오브젝트 형식으로 파싱함
        
        JsonElement last_trade_price = jsonObj.get("last_trade_price");
        
        
        
        
        System.out.println("비트코인 가격: "+last_trade_price);
        
        
        httpClient.close();


    }
}

 

그 뒤 실행 파일에서 실행해보면 결과는 아래와 같다.

==============비트코인 가격  json 시작=================
status code: 200
{"symbol":"BTC-USD","price_24h":35666.0,"volume_24h":62.14906458,"last_trade_price":36196.52}
비트코인 가격: 36196.52

 

 

윈도우 환경에서 자바를 설치하는 방법을 체계적으로 알아본다.

 

혹시 컴퓨터에 자바가 설치되었는지 아닌지 확실하지 않다면 윈도우에서 cmd라고 쳐보자.

 

cmd 창에서 java -version이라고 치면 자바 버전이 나온다.


* 자바 설치 확인

위 메시지는 자바 JDK 1.8버전이 설치되어있다는 뜻입니다.

 

JAVA 8버전이 JDK1.8이고 JAVA 11버전이 JDK 11입니다.

 

JDK의 버전은 오래된 순으로 1.6, 1.7, 1.8, 9, 11, 12, 13, 14, 15 이런식으로 이어집니다.

 

* 자바C 설치 확인 (자바 컴파일러)

 

* 자바설치

아래 링크로 들어가던가, 아니면 구글에 jdk download를 검색한다.

www.oracle.com/kr/java/technologies/javase-downloads.html

 

위는 jdk SE 15버전인데 1.6~1.8버전도 거의 상관이 없다.

window64 installer를 클릭하여 설치해준다. 별도 로그인은 필요없다.

 

잘 설치가 되었다면 프로그램 폴더에 자바가 있을 것이다.

 

 

 

 

 

 

 

 

자바스크립트에서는 setTimeOut 메소드를 이용하여 일정 시간 뒤 로직을 실행시킬 수 있지만,

백단 자바에서는 timeTask를 써야한다.

 

예제는 아래와 같다.

ExampleTimer.java 파일을 만든 뒤 아래의 코드를 작성.

 

package com.timer.ex;

import java.util.Timer;
import java.util.TimerTask;
 
public class ExampleTimer {
 
    private Timer timer;
    
    //task 클래스 생성
    public class TaskToDo extends TimerTask {
        int count=0;
        
        @Override
        public void run() {
            System.out.println(count + "th " + "Task Done!");
            count += 1;
        }
    }
    /////////////////////
    
    
    //setTimer 메소드 선언
    public void setTimer(long delay, long period) {
        timer = new Timer();
        timer.schedule(new TaskToDo(), delay, period);
    }
    //////////////
    
    public static void main(String args[]) {
        
        ExampleTimer exampleTimer = new ExampleTimer();
        exampleTimer.setTimer(2000, 1000); //처음에 2초 뒤에 시작. 1초간격으로 실행
    }
}
 

 

setTimer가 (2000, 1000) 이므로 처음에 2초 있다가 시작하며 console에 초당 카운트가 되는것을 볼수 있다.

0th Task Done!
1th Task Done!
2th Task Done!
3th Task Done!
4th Task Done!
5th Task Done!

 

에러 java.sql.Timestamp cannot be cast to java.lang.String

 

DB에 timestamp 타입의 열을 만들면 자바에서 위의 에러를 뱉어낼 때가 있다.

 

이럴때는 쿼리문 또는 자바에서 데이트포맷을 변경해주어야 한다.

 

예를 들어 xml파일에 아래의 쿼리문을 입력하면

 

SELECT MEMBER_ID, MEMBER_PASS, LOGIN_DATE
FROM MEMBER

 

LOGIN_DATE의 데이터타입이 timestamp라면 java.sql.Timestamp cannot be cast to java.lang.String 에러를 띄우게 되는데 그때는 아래의 쿼리문으로 바꾸면 된다.

SELECT MEMBER_ID, MEMBER_PASS,
DATE_FORMAT(LOGIN_DATE, '%Y-%m-%d %H:%i:%s') AS LOGIN_DATE
FROM MEMBER

 

march, june같은 영어 월로 바꾸려면 %m을 %M으로 바꾸면된다.

 

또한 2020-07-08 08:20:05  <<이런 데이터를 15914634~~같은 UNIX타입으로 변화시키려면 아래 자바코드를 이용한다.

 

import java.util.Date

//String으로 되어 있는 날짜를 UNIX타입으로 저장
java.sql.Timestamp date_timestamp01 = java.sql.Timestamp.valueOf(date_string);

long date_timestamp02 = date_timestamp01.getTime(); //date_timestamp02의 값은 159823~~~값을 가진다.


//현재 시간을 UNIX타입 으로 저장하는 코드
Long now01 = System.currentTimeMillis();


//현재 시간을 yyyy-MM-dd HH:mm:ss 포맷으로 저장하는 코드
Date now = new Date(); //Date타입으로 변수 선언
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //데이트 포맷
String date_string = dateFormat.format(now); //날짜가 string으로 저장

스프링 프레임워크에서 myBatis사용하여 mySQL db연동하는 방법

 

결론적으로 아래와 같이 파일구성이 되야한다.

 

 

예제파일-----

 

jdbcTest2.zip
0.03MB

--------

 

그럼 차근차근 진행해본다.

 

 

1. src/main/resources에 파일 생성

 

1) mybatis-config.xml 파일 생성

 

아래 코드를 mybatis-config.xml에 넣는다.

 

이 파일을 생성하여야 log dependency를 넣었을 때 오류가 나지 않는다.

 

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

</configuration>

 

2) log4jdbc.log4j2.properties 파일 생성

 

아래코드를 log4jdbc.log4j2.properties에 넣는다.

log4jdbc에 접속시켜주는 역할을 한다.

 

log4jdbc.log4j2.properties

log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator

 

3) logback.xml 생성

 

레벨을 설정해주는 파일이다.

 

아래코드를 logback.xml에 넣는다.

 

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml"/>

    log4jdbc-log4j2
	<logger name="jdbc.sqlonly"        level="DEBUG"/>
    <logger name="jdbc.sqltiming"      level="INFO"/>
    <logger name="jdbc.audit"          level="WARN"/>
    <logger name="jdbc.resultset"      level="ERROR"/>
    <logger name="jdbc.resultsettable" level="ERROR"/>
    <logger name="jdbc.connection"     level="INFO"/>
</configuration>

 

아래와 같이 파일들이 생성된다.

2. dependency 주입

 

pom.xml에 스프링, jdbc, 로그 관련 의존성을 주입한다.

 

아래 코드를 pom.xml에 붙여넣기한다.

<!-- db 연결 관련 -->
		<!-- spring-jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
			<!-- mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.38</version>
		</dependency>
			<!-- MyBatis 관련 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.3.1</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.5</version>
		</dependency>
				<!-- log 관련 -->
		<dependency>
			<groupId>org.bgee.log4jdbc-log4j2</groupId>
			<artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
			<version>1.16</version>
		</dependency>	
        
        				<!-- sprint-test 관련-->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>

 

그리고 <properties>태그안에 org.springframework-version을 4.2.3으로 변경시킨다.

	<properties>
		<java-version>1.6</java-version>
		<org.springframework-version>4.2.3.RELEASE</org.springframework-version>
		<org.aspectj-version>1.6.10</org.aspectj-version>
		<org.slf4j-version>1.6.6</org.slf4j-version>
	</properties>

 

 

3. VO와 DAO 생성

 

1) VO 생성

com.mysql.domain에 memberVO.java를 생성하여 아래 코드들을 넣는다.

 

MemberVO.java

package com.mysql.domain;

import java.sql.Date;

public class memberVO {

	String userid;
	String userpw;
	String username;
	String email;
	Date regdate;
	Date updatedate;
	
	public String getUserid() {
		return userid;
	}
	public void setUserid(String userid) {
		this.userid = userid;
	}
	public String getUserpw() {
		return userpw;
	}
	public void setUserpw(String userpw) {
		this.userpw = userpw;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Date getRegdate() {
		return regdate;
	}
	public void setRegdate(Date regdate) {
		this.regdate = regdate;
	}
	public Date getUpdatedate() {
		return updatedate;
	}
	public void setUpdatedate(Date updatedate) {
		this.updatedate = updatedate;
	}
	@Override
	public String toString() {
		return "MemberVO [userid=" + userid + ", userpw=" + userpw + ", username=" + username + ", email=" + email
				+ ", regdate=" + regdate + ", updatedate=" + updatedate + "]";
	}
}

 

2) DAO 생성

 

DAO는 데이터베이스와 연결시켜주는 역할을 한다.

 

1) com.mysql.persistence에 memberDAO.java를 생성하여 아래 코드들을 넣는다.

 

MemberDAO.java

package com.mysql.persistence;

import com.mysql.domain.MemberVO;

// 타입만 명세
	public interface MemberDAO extends GenericDAO<MemberVO, String> {

	}// interface


 

2) com.mysql.persistence에 memberDAOImpl.java를 생성하여 아래 코드들을 넣는다.

 

MemberDAOImpl.java

package com.mysql.persistence;

import org.springframework.stereotype.Repository;
import com.mysql.domain.MemberVO;


@Repository
public class MemberDAOImpl extends GenericDAOImpl<MemberVO, String> implements MemberDAO {

}

 

3) com.mysql.persistence에 GenericDAO.java를 생성하여 아래 코드들을 넣는다.

 

GenericDAO.java

package com.mysql.persistence;

import java.util.List;

public interface GenericDAO<E, K> {

	public K getTime();
	public void register(E vo);
	public E get(K userid);
	public List<E> getList();
	// 아래는 등록, 조회 구현 이후에 할 것임..
	//public void update();
	//public void delete();
	
}// interface

 

4) com.mysql.persistence에 GenericDAOImpl.java를 생성하여 아래 코드들을 넣는다.

 

GenericDAOImpl.java

package com.mysql.persistence;


import java.util.List;
import javax.inject.Inject;
import org.apache.ibatis.session.SqlSession;

// GenericDAO 인터페이스의 추상클래스들을 오버라이딩 해주어야 한다.
// 즉, 여기서 DB와 연결을 하고 SQL문을 처리해주어야 하므로 sessionTemplate을 인스턴스 변수로 갖고서 
// 이를 통해 CRUD 작업을 처리해주면 된다.
public abstract class GenericDAOImpl<E, K> implements GenericDAO<E, K> {

	@Inject
	private SqlSession sqlSession;
	
	private static final String namespace = 
			"com.mysql.mapper.MemberMapper";
	
	@Override
	public K getTime() {
		return sqlSession.selectOne(namespace + ".getNow");
	}

	@Override
	public void register(E vo) {
		sqlSession.insert(namespace + ".register", vo);
	}

	@Override
	public E get(K userid) {
		return sqlSession.selectOne(namespace + ".get", userid);
	}

	@Override
	public List<E> getList() {
		return sqlSession.selectList(namespace + ".getList");
	}

}// class

 

5) com.mysql.persistence에 TimeDao.java를 생성하여 아래 코드들을 넣는다.

 

TimeDAO.java

package com.mysql.persistence;


import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.springframework.stereotype.Repository;


@Repository
public class TimeDAO {

	@Inject
	private DataSource ds;
	
	
	public String getTime() throws Exception{
		
		Connection conn = ds.getConnection();
		PreparedStatement pstmt = conn.prepareStatement("select now()");
		
		ResultSet rs = pstmt.executeQuery();
		
		rs.next();
		return rs.getString(1);
		
	}// getTime()
	
	
}

 

4. root-context 코드 추가

 

root-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
		
		
	<!-- JDBC의 연결을 처리하는 기능을 가진 DataSource -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="net.sf.log4jdbc.sql.jdbcapi.DriverSpy"></property>
		<property name="url" value="jdbc:log4jdbc:mysql://127.0.0.1:3306/book_ex"></property>
		<property name="username" value="zerock"></property>
		<property name="password" value="12351235"></property>
	</bean>

	<!-- SqlSessionFactoryBean 생성 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
 		<!-- mybatis-config.xml 파일이 스프링이 동작할 때 같이 동작하도록 설정한 것. -->
		<property name="configLocation" value="classpath:mybatis-config.xml"></property>
		<property name="dataSource" ref="dataSource"></property>
		<property name="mapperLocations" value="classpath:mappers/**/*.xml"></property>
	</bean>

	<!-- sqlSession 을 SqlSessionTemplate으로 만든다. -->
	<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>


	<!-- 스프링이 관리하는 패키지에 com.mysql.persistence 를 추가한다. -->
	<context:component-scan base-package="com.mysql.persistence" />
	
</beans>

 

5. mapper 추가

 

resources에 mappers라는 패키지를 추가한 뒤에 memberMapper.xml 파일을 만든다.

 

그 뒤 아래 코드를 붙여넣는다.

 

memberMapper.xml 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mysql.mapper.MemberMapper">

	<!-- 이거에 접근할 때 namespace.id 로 접근한다. -->
	<!-- resultType은 자바의 타입과 매핑되는 것이 있다. 여기선 string이 java.lang.String과 매핑 -->
	<select id="getNow" resultType="string">
		select now()   <!-- 세미콜론 쓰면 안됨 -->
	</select>
	
	<insert id="register">
		insert into tbl_member(userid, userpw, username, email)
		values( #{userid} , #{userpw}, #{username}, #{email} );
	</insert>
	
	<!-- 
			XML Mapper를 작성할 때 매번 resultType을 패키지까지 포함된 클래스명을 작성하는 일이 번거롭다면
			MyBatis의 설정 파일인 mybatis-config.xml을 사용해서 다음과 같이 <typeAliases>를 작성하면된다.
			<typeAliases>
				<package name = "org.zerock.domain"/>
			</typeAliases>		
	-->
	<select id="get" resultType="com.mysql.domain.MemberVO">
		select *
		from tbl_member
		where userid = #{userid}
	
	</select>
	
	<select id="getList" resultType="com.mysql.domain.MemberVO">
		select *
		from tbl_member;
	</select>
</mapper>

 

 

6. src/test/java 폴더의 controller 패키지에 자바파일들 추가

 

AbstractTest.java

package com.mysql.controller;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/* 모든 테스트 파일이 상속할 추상클래스
 * - 어노테이션 자동 추가
 * - Logger 
 * */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"file:src/main/webapp/WEB-INF/spring/**/*.xml"})
public abstract class AbstractTest {

	protected static final Logger logger = 
			LoggerFactory.getLogger(AbstractTest.class);

}

 

ApplicationContextTest.java

package com.mysql.controller;
/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */

import javax.inject.Inject;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class ApplictationContextTest extends AbstractTest{

	@Inject
	private ApplicationContext ctxt;
	
	
	@Test
	public void test() {
		logger.info(""+ctxt);
		
	}// test()

}// class

 

DataSourceConnectionTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import static org.junit.Assert.fail;

import java.sql.SQLException;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class DataSourceConnectionTest extends AbstractTest{
	
	@Inject
	private DataSource ds;
	
	@Test
	public void test() throws SQLException {
		logger.info(""+ds.getConnection());
	}// test()

}// class

 

MemberDAOImplTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import javax.inject.Inject;

import org.junit.Test;
import com.mysql.domain.MemberVO;
import com.mysql.persistence.MemberDAO;

public class MemberDAOImplTest extends AbstractTest{

	@Inject
	private MemberDAO dao;
	
	@Test
	public void test() {
		logger.info(""+dao);
	}
	
	@Test
	public void getTimeTest() {
		logger.info(""+dao.getTime());
	}
	
	@Test
	public void registerTest(){
		MemberVO vo = new MemberVO();
		vo.setUserid("fff");
		vo.setUserpw("cccc");
		vo.setUsername("ejg");
		vo.setEmail("ej@g.com");
		
		// DB에 넣고 DB테이블에서 직접 확인해봐야 한다.
		dao.register(vo);
	}
	
//	@Test
//	public void getTest(){
//		logger.info(""+dao.get("wjheoid"));
//	}
//	
//	@Test
//	public void getListTest(){
//		logger.info(""+dao.getList());
//	}
	
}// class

 

SqlSessionFactoryBeanTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import javax.inject.Inject;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class SqlSessionFactoryBeanTest extends AbstractTest{

	@Inject
	SqlSessionFactoryBean factoryBean;
	
	@Test
	public void test(){
		logger.info(""+factoryBean);
	}// test()
	
	@Test
	public void sesseionTest(){
		try {
			logger.info(""+factoryBean.getObject().openSession().toString());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}// test()
	
}// class

 

TimeDAOTest.java

package com.mysql.controller;
/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */

import static org.junit.Assert.fail;

import javax.inject.Inject;

import org.junit.Test;
import com.mysql.persistence.TimeDAO;

public class TimeDAOTest extends AbstractTest{

	@Inject
	private TimeDAO dao;
	
	@Test
	public void test() throws Exception {
		logger.info(""+dao.getTime());
		
	}// test()
}// class

 

아래와 같이 파일들이 구성되어야 함

 

이후 MemberDAOImplTest에서 테스트를 하면 db에 값이 저장됨

 

위에 값들은 vo를 참조하여 만들면 된다.

jsonTest.zip
0.02MB

 

백단에서 프론트단으로 데이터를 전송해줄 때 많이 쓰이는 방식이 AJAX이다.

 

온라인상에 이미 API가 존재한다면 js에서 바로 $.ajax를 이용하거나 httpRequest를 이용해서 받아오면 되지만

API가 없다면 백단에서 직접 뿌려줘야 한다. 

 

그 방식을 나열해보면 아래와 같다.

1. Json 라이브러리를 이용하여 데이터값을 만들거나, 다른 페이지의 데이터를 가져와 Json형태로 만들어준다.

2. @RequestMapping과 @ResponseBody로 원하는 데이터를 Return 시켜준다.

3. 자바스크립트 ajax로 값을 받아온다.

4. 받아온 값을 html로 띄워 보여준다.

 

특히, 여기서는 우리가 잘아는 아래 처럼 $.ajax명령어가 아닌 jQuery의 DataTable()을 사용하여 데이터를 테이블형태로 바로 받아오겠다.

<script>
    $(function(){
        $.ajax({
            url:'./time.php',
            success:function(data){
                $('#time').append(data);
            }
        })
    })
</script>

 

1. @ResponseBody 작성

단순하게 {}를 만들어서 저장하는 방법도 있겠지만 명령어를 통해서 아래의 데이터를 작성해보겠다.

여기서는 Json 라이브러리만 제대로 알면 90%는 끝이다.

 

{"data":[{"extn":0,"name":0,"position":0,"office":0,"salary":0,"start_date":0},{"extn":1,"name":1,"position":1,"office":1,"salary":1,"start_date":1},{"extn":2,"name":2,"position":2,"office":2,"salary":2,"start_date":2},{"extn":3,"name":3,"position":3,"office":3,"salary":3,"start_date":3},{"extn":4,"name":4,"position":4,"office":4,"salary":4,"start_date":4},{"extn":5,"name":5,"position":5,"office":5,"salary":5,"start_date":5}]}

 

 

※ Json 파일 작성

 

1) Gson 메이븐 저장

pom.xml에 아래와 같이 의존성 주입

<!--Gson과 Json-->
<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20171018</version>
</dependency>
		
<dependency>
     <groupId>com.googlecode.json-simple</groupId>
     <artifactId>json-simple</artifactId>
     <version>1.1.1</version>
</dependency>
	
<dependency>
	<groupId>com.google.code.gson</groupId>
	<artifactId>gson</artifactId>
	<version>2.5</version>
</dependency>

참고로 JSONObject 처럼 대문자 JSON은 Json.org에서 제공하는 라이브러리고 JsonObject처럼 소문자 Json은 구글에서 제공하는 Gson이다.

보통 Gson을 많이 쓴다.

 

2) Json 형태 만들기

위의 데이터 형태를 보면 맨 바깥쪽에 {}로 중괄호가 있고 그안에 data:[{배열1},{배열2},{배열3}] 가 있는 형태이다.

 

즉, 맨 상위의 형태는 data와 array로 나눠진다.

따라서 맨위의 json object인 obj1에는 data와 array가 가게끔한다.

 

그 뒤 obj2로 데이터1, 데이터2, 데이터3을 만들어서 이것을 통틀어 jsonArray로 묶어서  맨위의 json object인 obj1에 저장해줄 것이다.

 

아래 코드에 주석으로 설명 써놓았다.

 

Gson 사용

@RequestMapping(value = "/aa", method = RequestMethod.GET)
	@ResponseBody
	public String home3() {
		
		//상위 오브젝트 생성
		JsonObject obj1 = new JsonObject();
		//data: 뒤에 들어갈 값인 jArray 생성
		JsonArray jArray = new JsonArray();
		
		//배열생성, jArray의 0번째 배열에 쭈루룩, 1번째 배열에 쭈루룩~
		for(int i=0; i<6; i++){
		
			JsonObject obj2 = new JsonObject();
			//obj2는 반드시 for문 안에 놓아야 한다. 그래야 중복이 안생긴다.
			
			obj2.addProperty("name",i);
			obj2.addProperty("position",i);
			obj2.addProperty("salary",i);
			obj2.addProperty("start_date",i);
			obj2.addProperty("office",i);
			obj2.addProperty("extn",i);
			
			jArray.add(obj2);

		}
		
		//마지막으로 최상위의 jsonObject에 data와 jArry를 넣어준다.
		
		obj1.add("data", jArray);
		
		String resp = obj1.toString();
		
		return resp;
	}

 

Json.org는 add를 put으로만 바꾸어주면 된다. 둘중 무엇을 쓰던 상관 없다.

 

Json.org 사용

@RequestMapping(value = "/bb", method = RequestMethod.GET)
	@ResponseBody
	public String home5() {
		
		//상위 오브젝트 생성
		JSONObject obj1 = new JSONObject();
		//data: 뒤에 들어갈 값인 jArray 생성
		JSONArray jArray = new JSONArray();
		
		//배열생성, jArray의 0번째 배열에 쭈루룩, 1번째 배열에 쭈루룩~
		for(int i=0; i<6; i++){
		
			JSONObject obj2 = new JSONObject();
			//obj2는 반드시 for문 안에 놓아야 한다. 그래야 중복이 안생긴다.
			
			obj2.put("name",i);
			obj2.put("position",i);
			obj2.put("salary",i);
			obj2.put("start_date",i);
			obj2.put("office",i);
			obj2.put("extn",i);
			
			jArray.put(obj2);

		}
		
		//마지막으로 최상위의 jsonObject에 data와 jArry를 넣어준다.
		
		obj1.put("data", jArray);
		
		String resp = obj1.toString();
		
		return resp;
	}

데이터가 없어서 밸류값을 i로 해놨지만 저 for문 안에서 얼마든지 다른 곳의 데이터를 가져와서 저장할 수 있다.

이때 get(i) 메소드가 많이 쓰인다.

 

이렇게 리턴을 해주고 주소창에 localhost:8080/aa 라고 치면 아래와 같이 나오면 성공이다.

2. JSP와 스크립트 작성

스크립트로 /aa주소에서 데이터를 받아와서 JSP에 띄워준다.

스크립트는 아래에 위치하는 것이 좋다.

 

테이블 id는 example로 해두고 jquery에서  $('#example').DataTable({ })를 사용해서 데이터를 쭈루룩 입력해준다.

 

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
<meta charset="utf-8">
      <script src='https://code.jquery.com/jquery-3.3.1.min.js'></script>
    <link rel="stylesheet" type="text/css" href="https://cdn.datatables.net/1.10.19/css/jquery.dataTables.css">
<script type="text/javascript" charset="utf8" src="https://cdn.datatables.net/1.10.19/js/jquery.dataTables.js"></script>
</head>

<body>
<table id="example" class="display" style="width:100%">
        <thead>
            <tr>
                <th>Name</th>
                <th>Position</th>
                <th>Office</th>
                <th>Extn.</th>
                <th>Start date</th>
                <th>Salary</th>
            </tr>
        </thead>

    </table>

<script>
  $(document).ready(function() {
    $('#example').DataTable( {
        "ajax": "/aa",
        "columns": [
            { "data": "name" },
            { "data": "position" },
            { "data": "office" },
            { "data": "extn" },
            { "data": "start_date" },
            { "data": "salary" }
        ]
    } );
} );  
    
</script>
</body>
</html>

 

주소창에 localhosot를 치면 아래와 같이 나오면 성공.

 

 

 

 

JSON 파싱에 대한 포스팅

 

우선 GSON이라는 dependency를 maven에 추가한다.

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

 

 

 

 

 

{"result":

 

{"account_data":

 

{"Account":"rNTkgxs5WG5mU5Sz26YoDVrHim5Y5ohC7",

"Balance":"20999000",

"Flags":1048576,

"LedgerEntryType":"AccountRoot",

"OwnerCount":0,

"PreviousTxnID":"43AB8056587462983030ED668EB5AA4245D90F7FC92514C0D87129FEBEF4FA80",

"PreviousTxnLgrSeq":47883205,

"RegularKey":"rfn2qMt4mBvvtJmWAJLmBrZN5z1fhCEkBg",

"Sequence":69736,

"index":"D11F09F2ED30B139D751C32D77EB3135905AEB4F9EC68EC55162F84D479E51B3"},

 

"ledger_hash":"FA31555279BBC949B4D92EFB80CD243C3CAD4E5F0B862742CEC631BBF49AA4EB",

"ledger_index":47883215,

"status":"success",

"validated":true}}

 

위와 같은 데이터가 있다.

 

나는 Balance 정보 20999000를 불러오려고 할 때, Json parsing을 이용한다.

 

위의 데이터가 response1에 저장되어 있다고 가정한다.

 

		JsonParser jsonParser= new JsonParser(); //JsonParser를 불러온다.
		
		
		JsonObject jsonObj= (JsonObject) jsonParser.parse(response1); //reponse1을 오브젝트 형식으로 파싱함
		
		JsonElement jsonElem = jsonObj.get("result");
        //우리가 원하는 데이터는 result: 뒤에 있는 부분이므로 JsonElement로 result 부분을 가져와준다.

		
		System.out.println("Balance: "+jsonElem.getAsJsonObject().get("account_data").getAsJsonObject().get("Balance"));
		System.out.println("원장번호: "+jsonElem.getAsJsonObject().get("ledger_index"));
    	//getAsJsonObject().get("인덱스명")을 통해서 값을 가져올 수 있다.
    

 

예제로 쓸 데이터가 없다면 이런 형식으로 저장

     String jsonStr = "{\"members\":["
             + "{\"name\":\"홍길동\","
             + "\"email\":\"gildong@hong.com\","
             + "\"age\":\"25\""
             + "},"
             + "{\"name\":\"홍길서\","
             + "\"email\":\"gilseo@hong.com\","
             + "\"age\":\"23\""
             + "}]}";

 

개요

SQL과 Java 객체를 연결하는 지속성 프레임워크이다.

이전에는 iBATIS라는 이름으로 Apache 프로젝트의 하나로 개발되고 이었다. 그러나 2010년 6월에 Apache 소프트웨어 재단에서 개발이 중단되어 현재는 MyBatis라는 이름으로 개발되고 있다.

SQL 문을 완전히 제어하고 싶을 때 사용하면 편하다.

 

명령어

 

사용 방법

[test.java]

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

java 파일 위에 위와 같이 써준다.

 

[test.xml]

 

 

명령문

 

 

1. myBatis / ibatis: SQL문을 제어하는 것을 돕는다.

 

관련 명령문

  • seletList("String", 매개변수)
  • selectOne("String", 매개변수)

 

2. httpSession: 로그인 관련하여 세션처리를 해준다. 사용자 정보를 조회하고 업뎃하는 등에 사용된다.

 

 

3. httpServletRequest하나의 요청에서 HttpServletRequest 객체가 소멸하기 까지 상태정보를 유지하고자 할 때, 한번의 요청으로 실행된 페이지끼리 정보를 공유하고자 할 때 사용된다.

 

- 참조

httpSession과 HttpServletRequest의 차이점

https://salguru.tistory.com/23

 

 

4. httpServletResponse: 응답할 클라이언트에 대한 정보와 동작 정보를 가지고 있는 객체

불러오기

ServletWebRequest servletContainer = (ServletWebRequest)RequestContextHolder.getRequestAttributes();

HttpServletRequest request = servletContainer.getRequest();
HttpServletResponse response = servletContainer.getResponse();

 

 

5. httpService: HTTP >> 데이터를 GET 또는 POST 방식으로 웹서버로 전송 >> XML 형식으로 리턴

 

 

6. IOException어떠한 입출력 예외의 발생을 통지하는 시그널을 발생시킨다. 클래스 선언시 "throws IOException"으로 사용

 

 

7. Spring security: HttpSecurity메소드를 사용하여 보안 인증을 만드는 라이브러리이다.

 

관련 명령문

  • getAuthentication()
  • getPrincipal()

 

8. UUID: 무작위 문자열을 생성하는 자바 유틸이다.

 

 

9. JacksonJSON 데이터 구조를 처리해주는 라이브러리이다.

 

관련 명령문

  • JsonParseException
  • JsonMappingException
  • ObjectMapper
  • TypeReference

10. UserAgent: http-header로 부터 요청된 user-agent를 분석하여 브라우저 정보를 획득한다.

 

 

11. jsoup: 웹크롤링을 도와주는 강력한 라이브러리이다.

 

참조

https://mommoo.tistory.com/83

 

 

12. gsonjson을 생성하고 파싱하는 구글에서 제공하는 라이브러리이다.

 

관련 명령문

  • Gson
  • JsonObject
  • JsonParser

 

13. deviceUtils: 현재 사용하는 디바이스를 판별해준다.

 

관련 명령문

  • isNormal()
  • isMobile()
  • isTablet()

 

+ Recent posts