안녕하세요 ~ 오늘은 미세먼지에 대해서 설명해드리겠습니다. 백 부분에 대해서 좀 더 설명해드릴 예정입니다 ~ ლ(╹◡╹ლ)

 

제일 먼저 테이블에 있는 내용과 동일하게 작성한 

 

AirqualityDTO 먼저 보여드리겠습니다.

package com.project.airquality;

public class AirqualityDTO {
	private String stationname; //측정소 이름
	private String datatime;	//데이터 시간
	private String pm10value;		//미세먼지
	private String pm25value;		//초미세먼지
	
	public AirqualityDTO() {
		super();
	}

	public AirqualityDTO(String stationname, String datatime, String pm10value, String pm25value) {
		super();
		this.stationname = stationname;
		this.datatime = datatime;
		this.pm10value = pm10value;
		this.pm25value = pm25value;
	}

	@Override
	public String toString() {
		return "AirqualityDTO [stationname=" + stationname + ", datatime=" + datatime + ", pm10value=" + pm10value
				+ ", pm25value=" + pm25value + "]";
	}

	public String getStationname() {
		return stationname;
	}

	public void setStationname(String stationname) {
		this.stationname = stationname;
	}

	public String getDatatime() {
		return datatime;
	}

	public void setDatatime(String datatime) {
		this.datatime = datatime;
	}

	public String getPm10value() {
		return pm10value;
	}

	public void setPm10value(String pm10value) {
		this.pm10value = pm10value;
	}

	public String getPm25value() {
		return pm25value;
	}

	public void setPm25value(String pm25value) {
		this.pm25value = pm25value;
	}
	
	
	
}

 

AirqualityController 입니다.

package com.project.airquality;

import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.project.station.StationDTO;
import com.project.station.StationService;
import com.project.weather.WeatherUtil;

@Controller
public class AirqualityController {
	AirqualityAPIPull pull;
	StationService stationservice;
	AirqualityService airqualityService;
	
	@Autowired
	public AirqualityController(AirqualityAPIPull pull, StationService stationservice,
			AirqualityService airqualityService) {
		super();
		this.pull = pull;
		this.stationservice = stationservice;
		this.airqualityService = airqualityService;
	}
	
	@RequestMapping("/airquality/getDataDust.do")
	public String WeathergetData(String stationId, String path,Model model) throws IOException{
		String result = pull.GetAPIDataDust();
		airqualityService.delete();
		List<AirqualityDTO> dustList = pull.DataSaveDust(result);
		for (int i = 0; i < dustList.size(); i++) {
			airqualityService.insert(dustList.get(i));
		}
		return "redirect:/monitoring/main?stationId="+stationId;
	}
	
	@RequestMapping("/airquality/getDataDustWeather.do")
	public String WeathergetData2(String stationId, String path,Model model) throws IOException{
		String result = pull.GetAPIDataDust();
		airqualityService.delete();
		List<AirqualityDTO> dustList = pull.DataSaveDust(result);
		for (int i = 0; i < dustList.size(); i++) {
			airqualityService.insert(dustList.get(i));
		}
		return "redirect:/weather/getlistDust.do?stationId="+stationId;
	}
	
}

 

AirqualityDAO입니다 ~

package com.project.airquality;

import java.util.List;

import com.project.station.StationDTO;

public interface AirqualityDAO {
	List<AirqualityDTO> readList(String statilonname);
	int insert(AirqualityDTO dto);
	int delete();
	AirqualityDTO read(String stationname);
	List<AirqualityDTO> allReadList();
}

 

AirqualityDAOImpl 입니다 ~

package com.project.airquality;

import java.util.HashMap;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class AirqualityDAOImpl implements AirqualityDAO{
	SqlSession sqlSession;
	
	@Autowired
	public AirqualityDAOImpl(SqlSession sqlSession) {
		super();
		this.sqlSession = sqlSession;
	}
	
	@Override
	public List<AirqualityDTO> readList(String stationname) {
		return sqlSession.selectList("com.project.airquality.select", stationname);
	}

	@Override
	public int insert(AirqualityDTO dto) {
		return sqlSession.insert("com.project.airquality.insert", dto);
	}

	@Override
	public int delete() {
		return sqlSession.delete("com.project.airquality.delete");
	}

	@Override
	public AirqualityDTO read(String stationname) {
		return sqlSession.selectOne("com.project.airquality.read", stationname);
	}

	@Override
	public List<AirqualityDTO> allReadList() {
		return sqlSession.selectList("com.project.airquality.allreadlist");
	}

}

 

AirqualityService 입니다.

package com.project.airquality;

import java.util.List;

import com.project.station.StationDTO;

public interface AirqualityService {
	List<AirqualityDTO> airqualityList(String stationname);
	int insert(AirqualityDTO dto);
	int delete();
	AirqualityDTO read(StationDTO station);
	List<AirqualityDTO> allReadList();
}

 

AirqualityServiceImpl 입니다.

package com.project.airquality;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.project.station.StationDTO;

@Service
public class AirqualityServiceImpl implements AirqualityService {
	AirqualityDAO dao;

	@Autowired
	public AirqualityServiceImpl(AirqualityDAO dao) {
		super();
		this.dao = dao;
	}

	@Override
	public int insert(AirqualityDTO dto) {
		return dao.insert(dto);
	}

	@Override
	public List<AirqualityDTO> airqualityList(String stationname) {
		return dao.readList(stationname);
	}

	@Override
	public int delete() {
		return dao.delete();
	}

	@Override
	public AirqualityDTO read(StationDTO station) {
		String stationname = "";
		double lon = Double.parseDouble(station.getMap_longtude());
		double lat = Double.parseDouble(station.getMap_latitude());
		String mapaddr = station.getAddr_detail().substring(0,3);
		if(mapaddr.equals("한림읍")) { //주소에서 한번 거름
			stationname = "한림읍";
		}else if(mapaddr.equals("성산읍")){
			stationname = "성산읍";
		}else if(mapaddr.equals("대정읍")){
			stationname = "대정읍";
		}else if(mapaddr.equals("애월읍")){
			stationname = "애월읍";
		}else if(mapaddr.equals("남원읍")){
			stationname = "남원읍";
		}else if(mapaddr.equals("조천읍")){
			stationname = "조천읍";
		}else { //나머지는 좌표로 대략적으로
			if(lon<=126.22) {
				if(lat<33.28) {
					stationname = "대정읍";
				}else {
					stationname = "고산리";
				}
			}else if(lon<=126.27) {
				if(lat<=33.28) {
					stationname = "대정읍";
				}else if(lat<=33.38) {
					stationname = "고산리";
				}else {
					stationname = "한림읍";
				}
			}else if(lat<=33.33) {
				if(lon<=126.37) {
					stationname = "대정읍";
				}else if(lon<=126.54) {
					stationname = "강정동";
				}else if(lon<=126.67) {
					stationname = "동홍동";
				}else {
					stationname = "남원읍";
				}
			}else if(lat>33.33) {
				if(lon<=126.30) {
					stationname = "한림읍";
				}else if(lat<=33.38 && lon<126.37) {
					stationname = "한림읍";
				}else if(lat>33.38 && lon<126.37) {
					stationname = "애월읍";
				}else if(lon<126.42) {
					stationname = "애월읍";
				}else if(lon<126.49) {
					stationname = "노형로";
				}else if(lon<126.53) {
					stationname = "연동";
				}else if(lon<126.55) {
					stationname = "이도동";
				}else if(lon<126.62) {
					stationname = "화북동";
				}else if(lon<126.82) {
					stationname = "조천읍";
				}else {
					stationname = "성산읍";
				}
			}
		}
		return dao.read(stationname);
	}

	@Override
	public List<AirqualityDTO> allReadList() {
		System.out.println("에어퀄리티서비스임플 실행되나?????????????????????????");
		return dao.allReadList();
	}
	

}

 

airquality.xml 메퍼입니다 ~

새로 받아올 경우 기존에 있는 데이터를 삭제하고 새로운 데이터를 받아오도록 하였습니다.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.project.airquality">
	<insert id="insert" parameterType="airquality">
		insert into AIRQUALITY_TB values(
		#{stationname}, #{datatime}, #{pm10value}, #{pm25value})
	</insert>
	<delete id="delete">
		delete from AIRQUALITY_TB 
	</delete>
	<select id="read" parameterType="String" resultType="airquality">
		select * from AIRQUALITY_TB where stationname = #{stationname}
	</select>
	<select id="allreadlist" resultType="airquality">
		select * from AIRQUALITY_TB
	</select>
</mapper>

미세먼지API

미세먼지는 아픈 손가락이에요 ..

포스팅을 할 때 A와 B로 Back과 Front로 계획했습니다만, 미세먼지는 좀 더 복잡하여 한 파트 더 글 작성을 하겠습니다.

제일 중요한 부분만 보여드리겠습니다.

 

package com.project.airquality;

import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
//import java.util.List;
//
//import javax.xml.parsers.DocumentBuilderFactory;
//
//import org.json.simple.JSONObject;
//import org.json.simple.parser.JSONParser;
//
//import com.project.dust.dustDTO;
import java.util.List;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.springframework.stereotype.Service;

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

//시도별 실시간 측정정보 조회
//https://www.data.go.kr/tcs/dss/selectApiDataDetailView.do?publicDataPk=15073861
//요청주소 http://apis.data.go.kr/B552584/ArpltnInforInqireSvc/getCtprvnRltmMesureDnsty
//서비스URL http://apis.data.go.kr/B552584/ArpltnInforInqireSvc

@Service
public class AirqualityAPIPull {
	public String GetAPIDataDust() throws IOException {
		StringBuilder urlBuilder = new StringBuilder(
				"http://apis.data.go.kr/B552584/ArpltnInforInqireSvc/getCtprvnRltmMesureDnsty"); /* URL */
		urlBuilder.append("?" + URLEncoder.encode("serviceKey", "UTF-8")
				+ "=serviceKey"); /*
																																 * 서비스
																																 */
		urlBuilder.append("&" + URLEncoder.encode("returnType", "UTF-8") + "="
				+ URLEncoder.encode("json", "UTF-8")); /* xml 또는 json */
		urlBuilder.append("&" + URLEncoder.encode("numOfRows", "UTF-8") + "="
				+ URLEncoder.encode("100", "UTF-8")); /* 한 페이지 결과 수 */
		urlBuilder
				.append("&" + URLEncoder.encode("pageNo", "UTF-8") + "=" + URLEncoder.encode("1", "UTF-8")); /* 페이지번호 */
		urlBuilder.append("&" + URLEncoder.encode("sidoName", "UTF-8") + "=" + URLEncoder.encode("제주",
				"UTF-8")); /*
							 * 시도 이름(전국, 서울, 부산, 대구, 인천, 광주, 대전, 울산, 경기, 강원, 충북, 충남, 전북, 전남, 경북, 경남, 제주, 세종)
							 */
		urlBuilder.append(
				"&" + URLEncoder.encode("ver", "UTF-8") + "=" + URLEncoder.encode("1.0", "UTF-8")); /* 버전별 상세 결과 참고 */
		URL url = new URL(urlBuilder.toString());
		HttpURLConnection conn = (HttpURLConnection) url.openConnection();
		conn.setRequestMethod("GET");
		conn.setRequestProperty("Content-type", "application/json");
		BufferedReader rd;
		if (conn.getResponseCode() >= 200 && conn.getResponseCode() <= 300) {
			rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
		} else {
			rd = new BufferedReader(new InputStreamReader(conn.getErrorStream()));
		}
		StringBuilder sb = new StringBuilder();
		String line;
		while ((line = rd.readLine()) != null) {
			sb.append(line);
		}
		rd.close();
		conn.disconnect();
		return sb.toString();
	}

	public List<AirqualityDTO> DataSaveDust(String result) {
		// Json parser를 만들어 만들어진 문자열 데이터를 객체화
		List<AirqualityDTO> dustList = new ArrayList<AirqualityDTO>();
		JSONParser parser = new JSONParser();
		JSONObject obj;

		try {
			obj = (JSONObject) parser.parse(result);
			// response 키를 가지고 데이터를 파싱
			JSONObject parse_response = (JSONObject) obj.get("response");
			// response 로 부터 body 찾기
			JSONObject parse_body = (JSONObject) parse_response.get("body");
			// body 로 부터 items 찾기
			JSONArray parse_items = (JSONArray) parse_body.get("items");

			String category;
			JSONObject data; // parse_item은 배열형태이기 때문에 하나씩 데이터를 하나씩 가져올때 사용
			// 카테고리와 값만 받아오기
			String dataTime = ((JSONObject) parse_items.get(0)).get("dataTime").toString();
			for (int i = 0; i < parse_items.size(); i++) {
				AirqualityDTO dust = new AirqualityDTO();
				data = (JSONObject) parse_items.get(i);
				Object pm10Value = data.get("pm10Value");
				Object pm25Value = data.get("pm25Value");
				Object stationName = data.get("stationName");
				dust.setPm10value((String) pm10Value);
				dust.setPm25value((String) pm25Value);
				dust.setStationname((String) stationName);
				dust.setDatatime(dataTime);
				dustList.add(dust);
				}
			
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return dustList;
		
	}
}

공공데이터에 있는 코드에서 수정해서 사용했고 xml은 손대기 번거로워서 json으로 받아올 수 있게 작업하였습니다.

 

공공데이터API

https://www.data.go.kr/tcs/dss/selectApiDataDetailView.do?publicDataPk=15073861 

 

한국환경공단_에어코리아_대기오염정보

각 측정소별 대기오염정보를 조회하기 위한 서비스로 기간별, 시도별 대기오염 정보와 통합대기환경지수 나쁨 이상 측정소 내역, 대기질(미세먼지/오존) 예보 통보 내역 등을 조회할 수 있다.

www.data.go.kr

밑에 있는 건 검색해도 정보 없어서 위에 있는 걸로 다시 사용했고, 여기서 '시도별 측정정보조회'로 봤습니다.

시를 '제주'로 설정하여, 제주도에 있는 13곳의 미세먼지 측정소 값을 가져오게 하였습니다.

 

측정소명 / 업데이트 시간 (미세먼지 API는 1시간에 한 번씩 받을 수 있습니다) / 미세먼지 / 초미세먼지 순입니다.

Oracle 테이블
오라클 내 미세먼지 테이블 데이터

 

이렇게 가져온 가져온 데이터를 가공하여 사이트에 뿌릴 수 있게 하였는데요,

https://www.jejudatahub.net/data/view/data/895

 

제주데이터허브

 

www.jejudatahub.net

제주데이터허브를 통해서 측정소의 정보를 가져왔습니다만,

실제로 API로 받아오는 측정소 값은 총 13개, 하지만 제주데이터허브에서는 9개 ..

수기로 미세먼지 측정소의 위치를 찾는 작업을 하였고, 구글 맵을 통해서 측정소의 위치를 경도와 위도로 바꿨습니다만,

 

제주도는 .. 가로가 더 긴 섬이잖아요 .. ?

그래서 경도와 위도를 x와 y로 바꾸는 작업도 하였습니다 .. (흘러내리는 눈물)

 

밑작업은 이 정도 했고 목요일엔 좀 더 상세한 미세먼지 API Back 작업 부분을 보여드리겠습니다 ~! (. ❛ ᴗ ❛.)

 

반갑읍니다 즐거운 주말이네요 ~ 오늘은 몽고DB를 이용한 FAQ의 백엔드 부분을 포스팅하고자합니다. (^人^)

 

몽고DB는 좀 재밌는 .. 일화가 있는데요 .. ?

바로 .. 해킹 사건입니다 .. 몽고DB에 비밀번호를 걸지 않을 경우 해킹당할 수 있습니다. 조심하시오 ..

 

발표 때 쓸려고 이쁜 데이터를 넣어뒀는데 뭔가 날라갈 거 같아서 백업해둔 게 빛을 발휘했습니다.

사실 그런 거짓 데이터 만드는 거 얼마 안 걸리는데 은근 머리 쓰잖아요 .. ?

 

해킹당해버린 .. 몽고DB

 

 

다른 건 다 오라클 / mysql 사용했는데 FAQ만 몽고DB로 한 이유는,

다양한 DB를 쓰기 위해서였습니다.

근데 페이징도 간단하고 그래서 좋았었움 ㅎ0ㅎ ~~ 프론트 부분은 내일 보여드리겠습니다 !@


테이블 먼저 보여드리겠습니다. 몽고DB의 경우 시퀀스는 없지만 어떻게 만든 걸 보고,

그거 쓰면 되겠거니 했는데 프라이머리키는 절대적으로 '_id'로만 가능하다는 걸 나중에 알았습니다 ..

그 강제 시퀀스 문장 찾아다닐려고 한창 구글링했는데 .. (´。_。`) 

 

보시면 title과 content가 있습니다.

몽고DB 테이블

글번호 / 날짜 / 매니저 아이디까지는 받을 필요가 없어서 딱 '_id', 'title', 'content'만 있습니다 !@

 

맛있는 몽고DB 패키지

이중에 Criteria와 Paging는 사용되지 않았습니다 ~~


제일 먼저 FAQDTO 보여드리겠습니다.

DB에 있는대로 생성해줬고요 ~

package com.project.faq;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "faq")
public class FaqDTO {
	@Id
	private String _id;
	private String title;
	private String content;
	
	public FaqDTO() {
	}
	
	public FaqDTO(String _id, String title, String content) {
		super();
		this._id = _id;
		this.title = title;
		this.content = content;
	}
	
	@Override
	public String toString() {
		return "faqDTO [_id=" + _id + ", title=" + title + ", content=" + content + "]";
	}

	public String get_id() {
		return _id;
	}

	public void set_id(String _id) {
		this._id = _id;
	}

	public String gettitle() {
		return title;
	}

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

	public String getcontent() {
		return content;
	}

	public void setcontent(String content) {
		this.content = content;
	}
	
}

 

FaqMongoDAO입니다. 실제로 웹사이트에 구현돼있는 기술은 CRUD, list, paging, search 입니다.

package com.project.faq;

import java.util.List;

public interface FaqMongoDAO {
		public List<FaqDTO> findCriteria(String key,String value);
		public FaqDTO findById(String key,String value);
		public void insertDocument(FaqDTO doc);
		public void insertAllDocument(List<FaqDTO> docs);
		public void update(FaqDTO document);	//업데이트
		public void delete(String _id);			//삭제
		
		//페이징 처리돼있는 목록 화면
		public List<FaqDTO> findAll();
		public List<FaqDTO> findAll(int pageNo);//페이징
}

 

FaqMongodbDAOImpl입니다.

package com.project.faq;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

@Repository
public class FaqMongodbDAOImpl implements FaqMongoDAO {
	//spring-data-mongodb에서 제공하는 라이브러리
	MongoTemplate mongoTemplate;
	//페이징처리와 소트를 쉽게 구현하기 위해서 (spring-data-commons라이브러리에서 제공) - CRUD(CLRUD)를 위한 메소드를 제공
	FaqRepository FaqRepository; //SimpleMongoRepository이용해서 작업
	
	@Autowired
	public FaqMongodbDAOImpl(MongoTemplate mongoTemplate, FaqRepository faqRepository) {
		super();
		this.mongoTemplate = mongoTemplate;
		this.FaqRepository = faqRepository;
	}
	
	@Override
	public void insertDocument(FaqDTO doc) {
		mongoTemplate.insert(doc);		
	}

	//search
	@Override
	public List<FaqDTO> findCriteria(String key, String value) {
		String[] data =  key.split(",");
		Criteria criteria = new Criteria(data[0]);
		//^ =>해당 필드가 ^다음의 문자열로 시작하는 데이터 => like 연산자와 동일 where dept like '인사%' 
		//criteria.regex("^"+value);
		criteria.regex(".*"+value+".*");//dept like '%사%'
		Query query = new Query(criteria);
		List<FaqDTO> docs = mongoTemplate.find(query, FaqDTO.class,"faq");
		System.out.println("dao=>"+docs);
		return docs;
	}
	
	
	//
	@Override
	public FaqDTO findById(String key, String value) {
		//Criteria객체는 spring data mongodb에서 조건을 모델링한 객체
		//어떤 필드에 어떤 조건을 적용할 것인지 정의
		//필드명과 필드의 조건을 정의하면 내부에서 json의 쿼리조건을 만들어 처리
		//1. 조건을 객체로 정의
		Criteria criteria = new Criteria(key);
		//조건에 대한 설정
		criteria.is(value);
		
		//2.Criteria객체를 이용해서 Query를 생성
		System.out.println("findById->"+value);
		Query query = new Query(criteria);
		FaqDTO doc = mongoTemplate.findOne(query, FaqDTO.class,"faq");
		System.out.println("doc ~~~"+doc);
		return doc;
	}

	@Override
	public void update(FaqDTO document) {
		//조건(Criteria,Query) - 조건에 만족하는 document를 수정
		Criteria criteria = new Criteria("_id");
		criteria.is(document.get_id());
		Query query = new Query(criteria);
		
		//업데이트기능을 수행하는 객체를 생성하고 적절한 값을 셋팅
		Update update = new Update();
		update.set("title", document.gettitle());
		update.set("content", document.getcontent());
		System.out.println("query : "+query);
		System.out.println("update : "+update);
		mongoTemplate.updateFirst(query, update,"faq");
	}
	
	//https://souning.tistory.com/68
	//https://sg-choi.tistory.com/388
	public void delete(String _id){
        Criteria criteria = new Criteria("_id");
		criteria.is(_id);
        Query query = new Query(criteria);
        System.out.println("DAOImpl _id : "+_id);
        mongoTemplate.remove(query,"faq");
        System.out.println("DAOImpl"+query);
    }
	
	@Override
	public List<FaqDTO> findAll() {
		return mongoTemplate.findAll(FaqDTO.class,"faq");
	}
	
	//리스트 페이징처리
	@Override
	public List<FaqDTO> findAll(int pageNo) {
		Page<FaqDTO> page = FaqRepository.findAll(new PageRequest(pageNo, 10));
		return page.getContent();
	}

	@Override
	public void insertAllDocument(List<FaqDTO> docs) {
		// TODO Auto-generated method stub
		
	}


}

 

FaqMongoService입니다.

package com.project.faq;

import java.util.List;


public interface FaqMongoService {
	//데이터 찾기
	public FaqDTO findById(String key,String value);
	//데이터 추가
	public void insertDocument(FaqDTO doc);
	public List<FaqDTO> findCriteria(String key,String value);
	public void update(FaqDTO document);	//진짜 업데이트
	public List<FaqDTO> findAll();
	public void delete(String _id);			//삭제
	
	//페이징처리
	public List<FaqDTO> findAll(int pageNo);//페이징
	void insertAllDocument(List<FaqDTO> docs);
}

 

FaqMongoServiceImpl입니다 ~

package com.project.faq;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class FaqMongoServiceImpl implements FaqMongoService {
	FaqMongoDAO dao;
	
	@Autowired
	public FaqMongoServiceImpl(FaqMongoDAO dao) {
		super();
		this.dao = dao;
	}

	@Override
	public FaqDTO findById(String key, String value) {
		return dao.findById(key, value);
	}

	@Override
	public void insertDocument(FaqDTO doc) {
		dao.insertDocument(doc);
	}
	
	@Override
	public void insertAllDocument(List<FaqDTO> docs) {
		dao.insertAllDocument(docs);
	}

	@Override
	public List<FaqDTO> findCriteria(String key, String value) {
		return dao.findCriteria(key, value);
	}

	@Override
	public List<FaqDTO> findAll() {
		return dao.findAll();
	}

	@Override
	public List<FaqDTO> findAll(int pageNo) {	//페이징
		//PaginfAndSortingRepository의 findAll메소드를 호출하면 페이징 처리된 객체를 전달 받을 수 있다.
		//fiindAll 메소드 내부에서 페이징 처리를 할 수 있도록 PageRequest객체를 이용해서 실행할 페이지의 번호와 한 페이지를 구성할 document
		//를 매개 변수로 전달해야하 한다.
		return dao.findAll(pageNo);
	}

	@Override
	public void update(FaqDTO document) {
		System.out.println("서비스입플 도큐먼트입니다 ~~~ "+document);
		dao.update(document);
	}
	
	@Override
	public void delete(String _id) {
		System.out.println("서비스임플입니다 _id >> "+_id);
		dao.delete(_id);
	}

}

 

몽고DB에서 중요한 FaqRepository도 보여드리겠습니다 !

package com.project.faq;

import java.util.List;

import org.springframework.data.repository.PagingAndSortingRepository;

import oracle.jdbc.proxy.annotation.Post;

//spring-data 내부에서 자동으로 하위 객체를 생성하고 코드를 만들고 mongodv에서 데이터를 조회해서 매핑시킨다.
public interface FaqRepository extends PagingAndSortingRepository<FaqDTO, String>{
//	List<Post> findAllByOrderByIdDesc();
}

 

FaqIndexController입니다.

package com.project.faq;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class FaqIndexController {
	@RequestMapping("/faq.do")
	public String basefaq() {
		return "faq";
		
	}
}

 

대부분의 역할을 수행하는 FaqController입니다.

package com.project.faq;

import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class FaqController {
	FaqMongoService service;

	public FaqController() {
	}

	@Autowired
	public FaqController(FaqMongoService service) {
		super();
		this.service = service;
	}

	// inset페이지로 이동
	@RequestMapping(value = "/service/faqinsert", method = RequestMethod.GET)
	public String insertPage() {
		return "service_faqinsert"; // .jsp
	}

	// faq에 insert하기
	@RequestMapping(value = "/service/faqinsert", method = RequestMethod.POST)
	public String insert(FaqDTO document) {
		// System.out.println("컨트롤러:"+document);
		service.insertDocument(document);
		System.out.println("FAQ컨트롤러 ~~" + document);
		return "redirect:/admin_faq.do?pageNo=0";
	}

	// search 하기.
	@RequestMapping(value = "/faq/search", method = RequestMethod.POST)
	public ModelAndView search(String field, String criteria, String value) {
		List<FaqDTO> docs = service.findCriteria(field + "," + criteria, value);
		return new ModelAndView("faq_search", "faqlist", docs);
	}

	// 읽기
	@RequestMapping("/faq/detail")
	public ModelAndView findById(String key, String value, String action) {
		System.out.println("findById _id 1234 : " + value);
		FaqDTO list = service.findById(key, value);
		System.out.println("list 1234 : " + list);
		String view = "";
		if (action.equals("read")) {
			view = "service_faqread";
		} else {
			view = "service_faqupdate";
		}
		return new ModelAndView(view, "list", list);
	}

	// get : 디비에서 데이터 가져올 때
	// post : 디비에 데이터 생성, 수정 할 때

	// RESTful API
	//
	// get.article
	// post.article
	// put.article 기존 게시글에 덮어 씌우기 (업데이트. 통째로 덮어씌움)
	// patch.article 기존 게시글에 일부만 바꿔서 업데이트 (업데이트. 일부만 업데이트 함)
	// 개발자끼리 이렇게 개발하자고 약속

	@RequestMapping("/faq/list")
	public String mongolist(Model model) {
		List<FaqDTO> faqlist = service.findAll();
		model.addAttribute("faqlist", faqlist);
		return "list";
	}

	// user list
	// user list
	@RequestMapping("/faq/paginglist")
	public ModelAndView pagemongolist(String pageNo) {
		ModelAndView mav = new ModelAndView("service_faq");
		
		List<FaqDTO> faqlist = service.findAll(Integer.parseInt(pageNo));
		List<FaqDTO> faqcount = service.findAll();
		int total_article = faqcount.size();
		mav.addObject("faqlist", faqlist);
		mav.addObject("faqcount", total_article);
		return mav;
	}
//	@RequestMapping("/faq/paginglist")
//	public ModelAndView pagemongolist(String pageNo, HttpServletRequest request) {
//		List<FaqDTO> faqlist = service.findAll();
//		int total_article = faqlist.size();
//		// 페이징 객체
////		Paging paging = new Paging();
////		paging.setCri(pageNo);
//		paging.setTotalCount(total_article); // 리스트 총갯수 (디비에서 count(*) 가지고 와야 함)
//
//		request.setAttribute("paging", paging);
//
////		model.addAttribute("faqlist", faqlist);
////
////		List<FaqDTO> faqlist = service.findAll(Integer.parseInt(pageNo));
//		// System.out.println(pageNo);
//
//		return new ModelAndView("service_faq", "faqlist", faqlist);
//	}

	// admin list
	@RequestMapping("/admin_faq.do")
	public ModelAndView pagemongolist2(String pageNo) {
		ModelAndView mav = new ModelAndView("admin_faqlist");
		
		List<FaqDTO> faqlist = service.findAll(Integer.parseInt(pageNo));
		List<FaqDTO> faqcount = service.findAll();
		int total_article = faqcount.size();
		mav.addObject("faqlist", faqlist);
		mav.addObject("faqcount", total_article);
		return mav;
	}

	@RequestMapping(value = "/faq/update", method = RequestMethod.POST)
	public String update(FaqDTO document, @RequestParam String _id) {
		System.out.println("update test1234 : " + document);
		System.out.println("_id test1234 : " + _id);
		document.set_id(_id);
		service.update(document);

		return "redirect:/admin_faq.do?pageNo=0";
	}

	// admin delete
	@RequestMapping(value = "/faq/delete.do", method = RequestMethod.GET)
	public String delete(String _id) {
		System.out.println("FAQ 컨트롤러 ~~삭제하기 눌려짐");
		service.delete(_id);
		System.out.println("컨트롤러 document > " + _id);
		return "redirect:/admin_faq.do?pageNo=0";
	}
}

 

몽고DB를 사용하기 위해서는 pom.xml에 추가해야하는 내용도 있는데 남겨두겠습니다.

 

...
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb</artifactId>
			<version>1.6.0.RELEASE</version>
		</dependency>
...

 

위에도 남겨두었는데 내일은 프론트 부분을 포스팅하겠습니다 ~

+ Recent posts