새로운 프로젝트
1) New -> Spring Legacy Project
2) 설정해주기
* 어제한 것 경로설정
* 파일IO 디펜던시 추가하고 설정변경
//1) pom.xnl -> file 업로드/다운로드 관련 의존성추가
//2) MediaDTO -> posterMF, filenameMF 필드 추가, getter setter 함수 생성
//3) servlet-context.xml에 스프링빈 등록
◐ MediaDTO.java
// 스프링파일 객체 멤버변수
// <input type='file' name='posterMF' size='50'>
private MultipartFile posterMF;
// <input type='file' name='filenameMF' size='50'>
private MultipartFile filenameMF;
◐ servlet-context.xml
<!-- File 전송이 있는 경우 Spring 등록 -->
<!-- CommonsMultipartResolver -->
<beans:bean id="MultipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</beans:bean>
Static - 공유, 이어진다. 이미 메모리에 올라가 있는 것이기 때문.
mymelon 프로젝트
mp3,mp4 파일을 올릴 수 있고 audio, video가 재생되는 CRUD 게시판
기본적인 디렉토리 구조는 다음과 같다.
1. src/main/java
DBPKG
1) DBOpen.java
package DBPKG;
import java.sql.*;
public class DBOpen {
public static Connection getConnetion() throws Exception{
Class.forName("oracle.jdbc.OracleDriver");
Connection con = DriverManager.getConnection ("jdbc:oracle:thin:@//localhost:1521/xe","오라클아이디","오라클비밀번호");
return con;
}
}
kr.co.mymelon
1) HomeController.java
package kr.co.mymelon;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HomeController {
public HomeController() {
System.out.println("---------------HomeController() 객체생성됨");
}
private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
//mymelon 프로젝트 첫페이지 호출 명령어 등록
//http://localhost:8090/mymelon/home.do
@RequestMapping(value = "/home.do", method = RequestMethod.GET) //root 페이지 등록
public ModelAndView home() {
ModelAndView mav = new ModelAndView();
//redirect <- 등록된 명령어를 호출한다.
mav.setViewName("redirect:/media/list.do"); //* 이런 형식도 가능하다.
return mav;
}//home end
}
kr.co.mymelon.media
1) MediaCont.java
package kr.co.mymelon.media;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;
import net.utility.UploadSaveManager;
import net.utility.Utility;
@Controller
public class MediaCont {
public MediaCont() {
System.out.println("---------------MediaCont() 객체생성됨");
//확인용에는 절대 void 적지말기
}
private MediaDAO dao=new MediaDAO();
//결과확인 http://localhost:8090/mymelon/media/list.do
@RequestMapping(value="/media/create.do", method=RequestMethod.GET)
public String createForm() {
return "media/createForm";
}
//결과확인 http://localhost:8090/mymelon/media/create.do
//1) Insert Data
@RequestMapping(value="/media/create.do", method=RequestMethod.POST)
public ModelAndView createProc(MediaDTO dto, HttpServletRequest req) {System.out.println(dto);
//1) pom.xml -> file 업로드/다운로드 관련 의존성추가
//2) MediaDTO -> posterMF, filenameMF 필드 추가, getter setter 함수 생성
//3) servlet-context.xml에 스프링빈 등록
ModelAndView mav = new ModelAndView();
mav.setViewName("media/msgView");
mav.addObject("root", Utility.getRoot()); //mymelon
//전송된 파일 처리
// -> 실제 파일은 /media/storage폴더에 저장
// -> 저장된 파일관련 정보는 media테이블에 저장
// 파일에 저장될 실제 물리적인 경로
String basicPath = req.getRealPath("/media/storage");
//1)<input type='file' name='posterMF'>
//파일 가져오기
MultipartFile posterMF = dto.getPosterMF();
//파일 저장하고 리네임된 파일명 반환
String poster = UploadSaveManager.saveFileSpring30(posterMF, basicPath); //파일명과 경로명
//리네임된 파일명 dto객체 담기
dto.setPoster(poster);
//2) <input type='file' name='filenameMF'>
MultipartFile filenameMF = dto.getFilenameMF();
String filename = UploadSaveManager.saveFileSpring30(filenameMF, basicPath);
dto.setFilename(filename);
dto.setFilesize(filenameMF.getSize());
int cnt = dao.create(dto);
if(cnt == 0) {
mav.addObject("msg1", "<p>음원등록 실패!</p>");
mav.addObject("img", "<img src='../images/fail.png'>");
mav.addObject("link1", "<input type='button' value='목록으로' onclick='location.href=\"list.do\"'>");
mav.addObject("link1", "<input type='button' value='목록으로' onclick='location.href=\"create.do\"'>");
} else {
mav.addObject("msg1", "<p>음원등록 성공!</p>");
mav.addObject("img", "<img src='../images/sound.png'>");
mav.addObject("link1", "<input type='button' value='목록으로' onclick='location.href=\"list.do\"'>");
}//if end
return mav;
}
//2) List
@RequestMapping("/media/list.do")
public ModelAndView list() {
ModelAndView mav = new ModelAndView();
mav.setViewName("media/list");
mav.addObject("list", dao.list());
mav.addObject("root", Utility.getRoot()); //root
return mav;
}
//3) Read
@RequestMapping("/media/read.do")
public ModelAndView read(MediaDTO dto) {
ModelAndView mav = new ModelAndView();
int mediano = dto.getMediano();
dto = dao.read(mediano);
if(dto != null) {
String filename = dto.getFilename();
filename = filename.toLowerCase();
if(filename.endsWith(".mp3")) {
mav.setViewName("media/readMP3");
} else if(filename.endsWith(".mp4")) {
mav.setViewName("media/readMP4");
}//if end
}//if end
mav.addObject("dto",dto);
return mav;
}//read end
//4) Update
@RequestMapping(value ="/media/update.do", method=RequestMethod.GET)
public ModelAndView updateForm(MediaDTO dto) {
ModelAndView mav = new ModelAndView();
mav.setViewName("media/updateForm");
mav.addObject("dto", dao.read(dto.getMediano()));
return mav;
}
@RequestMapping(value ="/media/update.do", method=RequestMethod.POST)
public ModelAndView updateProc(MediaDTO dto, HttpServletRequest req ) {
ModelAndView mav = new ModelAndView();
mav.setViewName("media/msgView");
String basePath = req.getRealPath("/media/storage");
//수정전 지정된 기존의 정보 가져오기
MediaDTO oldDTO = dao.read(dto.getMediano());
//////////////////////////////////////////////
//--------- 파일을 수정할 것인지? --------- //
MultipartFile posterMF = dto.getPosterMF();
if(posterMF.getSize() > 0) {
//1)파일 크키가 0보다 큼 = 파일이 잘 전송됨
//2)기존파일 삭제
UploadSaveManager.deleteFile(basePath, oldDTO.getPoster());
String poster = UploadSaveManager.saveFileSpring30(posterMF, basePath);
dto.setPoster(poster);
}else {
dto.setPoster(oldDTO.getPoster());
}
MultipartFile filenameMF = dto.getFilenameMF();
if(filenameMF.getSize()>0){
UploadSaveManager.deleteFile(basePath, oldDTO.getFilename());
String filename = UploadSaveManager.saveFileSpring30(filenameMF, basePath);
dto.setFilename(filename);
dto.setFilesize(filenameMF.getSize());
}else {
dto.setFilename(oldDTO.getFilename());
dto.setFilesize(oldDTO.getFilesize());
}//if end
int cnt=dao.update(dto);
if(cnt==0) {
mav.addObject("msg1", "<p>음원수정실패!!</p>");
mav.addObject("img", "<img src='../images/fail.png'>");
mav.addObject("link1", "<input type='button' value='목록으로' onclick='location.href=\"list.do\"'>");
mav.addObject("link2", "<input type='button' value='다시시도' onclick='javascript:history.back()'>");
}else {
mav.addObject("msg1", "<p>음원수정성공~~</p>");
mav.addObject("img", "<img src='../images/sound.png'>");
mav.addObject("link1", "<input type='button' value='목록으로' onclick='location.href=\"list.do\"'>");
}//if end
return mav;
}
//5) delete
@RequestMapping(value ="/media/delete.do", method=RequestMethod.GET)
public ModelAndView deleteForm(MediaDTO dto) {
ModelAndView mav = new ModelAndView();
mav.setViewName("media/deleteForm");
mav.addObject("dto", dao.read(dto.getMediano()));
return mav;
}
@RequestMapping(value= "/media/delete.do", method=RequestMethod.POST)
public ModelAndView delete(MediaDTO dto) {
ModelAndView mav = new ModelAndView();
mav.setViewName("media/msgView");
int cnt=dao.delete(dto);
if(cnt==0) {
mav.addObject("msg1", "<p>음원삭제실패!!</p>");
mav.addObject("img", "<img src='../images/fail.png'>");
mav.addObject("link1", "<input type='button' value='목록으로' onclick='location.href=\"list.do\"'>");
mav.addObject("link2", "<input type='button' value='다시시도' onclick='javascript:history.back()'>");
}else {
mav.addObject("msg1", "<p>음원삭제성공~~</p>");
mav.addObject("img", "<img src='../images/sound.png'>");
mav.addObject("link1", "<input type='button' value='목록으로' onclick='location.href=\"list.do\"'>");
}//if end
return mav;
}
}
2) MediaDAO.java
package kr.co.mymelon.media;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import DBPKG.DBOpen;
public class MediaDAO {
// 1) create
public int create(MediaDTO dto) {
int cnt = 0;
try {
// 1. DB연결
Connection con = DBOpen.getConnetion();
StringBuilder sql = new StringBuilder();
// 2. Insert SQL문 작성
sql.append(" INSERT INTO media (mediano, title, rdate, poster, filename, filesize ) ");
sql.append(" VALUES( (select nvl(max(mediano),0)+1 as mediano from media) ");
sql.append(",? ,SYSDATE ,? ,? ,? ) ");
// 3. SQL문 변환
PreparedStatement pstmt = con.prepareStatement(sql.toString());
// 4. Value값 불러오기
pstmt.setString(1, dto.getTitle());
pstmt.setString(2, dto.getPoster());
pstmt.setString(3, dto.getFilename());
pstmt.setLong(4, dto.getFilesize());
// 5. 실행
cnt = pstmt.executeUpdate();
} catch (Exception e) {
System.out.println("실패:" + e);
}
return cnt;
}
// 2) list
public ArrayList<MediaDTO> list() {
ArrayList<MediaDTO> list = null;
try {
// 1. DB연결
Connection con = DBOpen.getConnetion();
StringBuilder sql = new StringBuilder();
// 2. Select SQL문 작성
sql.append(" SELECT mediano, title, rdate, poster, filename, filesize, mview ");
sql.append(" FROM media ");
sql.append(" WHERE mview='Y'");
sql.append(" ORDER BY mediano DESC ");
// 3. SQL문 변환
PreparedStatement pstmt = con.prepareStatement(sql.toString());
// 4. 결과를 rs에 저장, ResultSet은 결과를 저장하는 하나의 집합
ResultSet rs = pstmt.executeQuery();
// 5. rs의 내용을 next로 읽기
if (rs.next()) {
// 6. list에 ArrayList<SungjukDTO>로 차곡차곡 저장
list = new ArrayList<MediaDTO>(); // 전체 저장하기
do {
MediaDTO dto = new MediaDTO(); // 한 줄씩 저장하기
dto.setMediano(rs.getInt("mediano"));
dto.setTitle(rs.getString("title"));
dto.setRdate(rs.getString("rdate"));
dto.setPoster(rs.getString("poster"));
dto.setFilename(rs.getString("filename"));
dto.setFilesize(rs.getLong("filesize"));
dto.setMview(rs.getString("mview"));
list.add(dto);
} while (rs.next());
} else {
list = null;
} // if end
} catch (Exception e) {
System.out.println("목록 불러오기 실패!" + e);
}
return list;
}
// 3) read
public MediaDTO read(int mediano) {
MediaDTO dto = null;
try {
// 1. DB연결: DBOpen.java와 연결한다.
Connection con = DBOpen.getConnetion();
StringBuilder sql = new StringBuilder();
// 2. Select SQL문 작성
sql.append(" SELECT mediano, title, rdate, poster, filename, filesize, mview ");
sql.append(" FROM media ");
sql.append(" WHERE mediano=? ");
// 3. SQL문 변환
PreparedStatement pstmt = con.prepareStatement(sql.toString());
pstmt.setInt(1, mediano); // ?순서와 ?에 들어갈 자료형 주의
// 4. 결과를 rs에 저장
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
do {
dto = new MediaDTO(); // 한 줄씩 저장하기
dto.setMediano(rs.getInt("mediano"));
dto.setTitle(rs.getString("title"));
dto.setRdate(rs.getString("rdate"));
dto.setPoster(rs.getString("poster"));
dto.setFilename(rs.getString("filename"));
dto.setFilesize(rs.getLong("filesize"));
dto.setMview(rs.getString("mview"));
} while (rs.next());
} else {
dto = null;
} // if end
} catch (Exception e) {
System.out.println("회원정보 열람실패:" + e);
}
return dto;
}
public int update(MediaDTO dto) {
int cnt = 0;
try {
Connection con = DBOpen.getConnetion();
StringBuilder sql = new StringBuilder();
// 2. Update SQL문 작성
sql.append(" UPDATE media ");
sql.append(" SET title=?, poster=?, filename=?, filesize=? ");
sql.append(" WHERE mediano =? ");
// 3. SQL문 변환
PreparedStatement pstmt = con.prepareStatement(sql.toString());
// 4. dto로 데이터 받아오기
pstmt.setString(1, dto.getTitle());
pstmt.setString(2, dto.getPoster());
pstmt.setString(3, dto.getFilename());
pstmt.setLong(4, dto.getFilesize());
pstmt.setInt(5, dto.getMediano());
// 5. 실행횟수를 cnt에 담기
cnt = pstmt.executeUpdate();
} catch (Exception e) {
System.out.println("게시물 수정실패!: " + e);
}
return cnt;
}
public int delete(MediaDTO dto) {
int cnt = 0;
try {
Connection con = DBOpen.getConnetion();
StringBuilder sql = new StringBuilder();
// 2. Update SQL문 작성
sql.append(" DELETE FROM media ");
sql.append(" WHERE mediano =? ");
// 3. SQL문 변환
PreparedStatement pstmt = con.prepareStatement(sql.toString());
// 4. dto로 데이터 받아오기
pstmt.setInt(1, dto.getMediano());
// 5. 실행횟수를 cnt에 담기
cnt = pstmt.executeUpdate();
} catch (Exception e) {
System.out.println("게시물 수정실패!: " + e);
}
return cnt;
}
}
3) MediaDTO.java
package kr.co.mymelon.media;
import org.springframework.web.multipart.MultipartFile;
public class MediaDTO {
private int mediano;
private String title;
private String poster;
private String filename;
private long filesize;
private String mview;
private String rdate;
//--------------------------------------------------------------------
// 스프링파일 객체 멤버변수
// <input type='file' name='posterMF' size='50'>
private MultipartFile posterMF;
// <input type='file' name='filenameMF' size='50'>
private MultipartFile filenameMF;
//--------------------------------------------------------------------
public MediaDTO() {}
public int getMediano() {
return mediano;
}
public void setMediano(int mediano) {
this.mediano = mediano;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getPoster() {
return poster;
}
public void setPoster(String poster) {
this.poster = poster;
}
public String getFilename() {
return filename;
}
public void setFilename(String filename) {
this.filename = filename;
}
public long getFilesize() {
return filesize;
}
public void setFilesize(long filesize) {
this.filesize = filesize;
}
public String getMview() {
return mview;
}
public void setMview(String mview) {
this.mview = mview;
}
public String getRdate() {
return rdate;
}
public void setRdate(String rdate) {
this.rdate = rdate;
}
public MultipartFile getPosterMF() {
return posterMF;
}
public void setPosterMF(MultipartFile posterMF) {
this.posterMF = posterMF;
}
public MultipartFile getFilenameMF() {
return filenameMF;
}
public void setFilenameMF(MultipartFile filenameMF) {
this.filenameMF = filenameMF;
}
@Override
public String toString() {
return "MediaDTO [mediano=" + mediano + ", title=" + title + ", poster=" + poster + ", filename=" + filename
+ ", filesize=" + filesize + ", mview=" + mview + ", rdate=" + rdate + ", posterMF=" + posterMF
+ ", filenameMF=" + filenameMF + "]";
}
}
net.utility
1) EncodeFilter.java
package net.utility;
import java.io.*;
import javax.servlet.*;
public class EncodeFilter implements Filter {
@Override
public void destroy() {}
@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1,
FilterChain arg2) throws IOException, ServletException {
arg0.setCharacterEncoding("UTF-8");
arg2.doFilter(arg0, arg1);
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}//class end
2) FileDownload.java
package net.utility;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class FileDownload extends javax.servlet.http.HttpServlet {
// 서블릿 버전, 생략 가능
static final long serialVersionUID = 1L;
// web.xml에 접근 가능
private ServletConfig config = null;
// 기본 생성자
public FileDownload() {
super();
}
/**
* 톰캣 실행시 최초 1번만 실행 됩니다. init()은 생략가능
*
* @param config
* web.xml에 접근가능, 서블릿 환경 정보 저장 객체
*/
@Override
public void init(ServletConfig config) throws ServletException {
this.config = config;
}//init() end
// Form - get 방식 처리
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doProcess(request, response);
}//doGet() end
// Form - post 방식 처리
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doProcess(request, response);
}//doPost() end
protected void doProcess(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ServletContext ctx = config.getServletContext();
// 저장 폴더를 절대 경로로 변환
String dir = ctx.getRealPath(request.getParameter("dir"));
// 파일명 받기
String filename = request.getParameter("filename");
// 전체 절대 경로 조합
File file = new File(dir + "/" + filename);
String fileStr = dir + "/" + filename;
String contentType = getType(fileStr);
System.out.println("다운로드 타입: " + contentType);
String disposition = getDisposition(filename, getBrowser(request));
response.addHeader("Content-disposition", disposition);
response.setHeader("Content-Transfer-Encoding", "binary");
response.setContentLength((int) file.length());
response.setContentType(contentType);
response.setHeader("Connection", "close");
// 파일을 읽어올 크기 지정
byte buffer[] = new byte[4096];
try {
if (file.isFile()) {
// 파일을 읽어 오는 역활
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
// 사이트에 접속된 접속자에게 출력
BufferedOutputStream bos = new BufferedOutputStream(response.getOutputStream());
int read = 0;
// bis.read(buffer): 파일에서 4KB씩 읽어서
// buffer에 저장
// 파일의 끝이면 -1
while ((read = bis.read(buffer)) != -1) {
// 접속자로 출력
bos.write(buffer, 0, read);
}// while
bis.close();
bos.close();
}
} catch (Exception e) { }
}//doProcess() end
public String getType(String fileUrl) {
String type = "";
fileUrl = "file:" + fileUrl;
try {
URL u = new URL(fileUrl);
URLConnection uc = u.openConnection();
type = uc.getContentType();
} catch (Exception e) {
System.out.println(e.toString());
}
return type;
}//getType() end
public String getBrowser(HttpServletRequest request) {
String header = request.getHeader("User-Agent");
if (header.indexOf("MSIE") > -1) {
return "MSIE";
} else if (header.indexOf("Chrome") > -1) {
return "Chrome";
} else if (header.indexOf("Opera") > -1) {
return "Opera";
}
return "Firefox";
}//getBrowser() end
public static synchronized String getDisposition(String filename, String browser) {
String dispositionPrefix = "attachment;filename=";
String encodedFilename = null;
try {
if (browser.equals("MSIE")) {
encodedFilename = URLEncoder.encode(filename, "UTF-8").replaceAll("\\+", "%20");
} else if (browser.equals("Firefox")) {
encodedFilename ="\"" + new String(filename.getBytes("UTF-8"), "8859_1") + "\"";
} else if (browser.equals("Opera")) {
encodedFilename ="\"" + new String(filename.getBytes("UTF-8"), "8859_1") + "\"";
} else if (browser.equals("Chrome")) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < filename.length(); i++) {
char c = filename.charAt(i);
if (c > '~') {
sb.append(URLEncoder.encode("" + c, "UTF-8"));
} else {
sb.append(c);
}
}
encodedFilename = sb.toString();
} else {
System.out.println("Not supported browser");
}
} catch (Exception e) { }
return dispositionPrefix + encodedFilename;
}//getDisposition() end
}//class end
3) UploadSaveManager.java
package net.utility;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import org.apache.commons.fileupload.DiskFileUpload;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUpload;
import org.apache.commons.fileupload.FileUploadException;
import org.springframework.web.multipart.MultipartFile;
/**
* HttpServletRequestWrapper 클래스는 HttpServletRequest
* 인터페이스를 임시로 구현한 클래스로 개발자가 내부객체인
* request를 사용하지않고 새로운 형태로 request 객체를
* 만들어 사용할 경우 상속받는 클래스입니다.
* Apahce FileUpload 콤포넌트를 사용하기 편리하게 지원합니다.
* FileUpload API를 사용하는 HttpServletRequestWrapper 클래스로서
* HttpServletRequest에 기반한 API를 사용하기 위한 래퍼이다.
*
ServletRequest
│ △
│ │구현
│ └ ServletRequestWrapper
│ △
│ │
└─ HttpServletRequest │
△ request │상속
│ │
│ 구현 │
└─ HttpServletRequestWrapper
△
│
│상속
UploadManager - requestWrap
request = requestWrap;
public interface HttpServletRequest extends ServletRequest
public class HttpServletRequestWrapper extends ServletRequestWrapper
implements HttpServletRequest
public class UploadManager extends HttpServletRequestWrapper
*/
public class UploadSaveManager extends HttpServletRequestWrapper {
private boolean multipart = false;
private HashMap parameterMap; // 일반 <INPUT> 폼태그
private HashMap fileItemMap; // 전송된 <FILE> 태그 객체가 저장
/**
* 기본 생성자
* @param request
* @throws FileUploadException
*/
public UploadSaveManager(HttpServletRequest request) throws FileUploadException{
this(request, -1, -1, null);
}
/**
* 생성자
* @param request HttpServletRequest 객체
* @param threshold 메모리에 저장할 최대크기
* @param max 업로드할 최대 파일크기
* @param repositoryPath 업로드 경로
* @throws FileUploadException
*/
public UploadSaveManager(HttpServletRequest request,
int threshold, int max, String repositoryPath) throws FileUploadException {
super(request);
parsing(request, threshold, max, repositoryPath);
}
/**
* 일반 입력 필드와 파일 필드를 MAP에 저장
* @param request HttpServletRequest 객체
* @param threshold 메모리에 저장할 최대크기
* @param max 업로드할 최대 파일크기
* @param repositoryPath 업로드 경로
* @throws FileUploadException
*/
private void parsing(HttpServletRequest request,
int threshold, int max, String repositoryPath) throws FileUploadException {
if (FileUpload.isMultipartContent(request)) {
multipart = true;
parameterMap = new java.util.HashMap();
fileItemMap = new java.util.HashMap();
DiskFileUpload diskFileUpload = new DiskFileUpload();
if (threshold != -1) {
diskFileUpload.setSizeThreshold(threshold);
}
diskFileUpload.setSizeMax(max);
if (repositoryPath != null) {
diskFileUpload.setRepositoryPath(repositoryPath);
}
java.util.List list = diskFileUpload.parseRequest(request);
for (int i = 0 ; i < list.size() ; i++) {
FileItem fileItem = (FileItem) list.get(i);
String name = fileItem.getFieldName();
if (fileItem.isFormField()) {
// 일반 폼태그라면 처리
String value = fileItem.getString();
String[] values = (String[]) parameterMap.get(name);
if (values == null) {
values = new String[] { value };
} else {
String[] tempValues = new String[values.length + 1];
System.arraycopy(values, 0, tempValues, 0, 1);
tempValues[tempValues.length - 1] = value;
values = tempValues;
}
parameterMap.put(name, values);
} else {
// 파일 태그라면 처리
System.out.println("전송 파일 발견됨 저장명: " + name);
System.out.println("전송 파일 발견됨 파일명: " + fileItem.getName());
// 키: 파일명, 파일 객체
fileItemMap.put(name, fileItem);
}
}
addTo(); // request 속성으로 설정한다.
}
}
/**
* 파일을 전송하는 enctype="multipart/form-data"인경우 true리턴
* @return enctype="multipart/form-data"인경우 true리턴
*/
public boolean isMultipartContent() {
return multipart;
}
/**
* 주어진 파라미터에 대한 값을 리턴
*/
public String getParameter(String name) {
if (multipart) {
String[] values = (String[])parameterMap.get(name);
if (values == null) return null;
return values[0];
} else
return super.getParameter(name);
}
/**
* 파라미터의 값들을 리턴
*/
public String[] getParameterValues(String name) {
if (multipart)
return (String[])parameterMap.get(name);
else
return super.getParameterValues(name);
}
/**
* 전체 파라미터의 이름을 리턴
*/
public Enumeration getParameterNames() {
if (multipart) {
return new Enumeration() {
Iterator iter = parameterMap.keySet().iterator();
public boolean hasMoreElements() {
return iter.hasNext();
}
public Object nextElement() {
return iter.next();
}
};
} else {
return super.getParameterNames();
}
}
public Map getParameterMap() {
if (multipart)
return parameterMap;
else
return super.getParameterMap();
}
/**
* 지정한 파라미터 이름과 관련된 FileItem을 리턴합니다.
* @param name
* @return
*/
public FileItem getFileItem(String name) {
if (multipart)
return (FileItem) fileItemMap.get(name);
else
return null;
}
/**
* 임시로 사용된 업로드 파일을 삭제합니다.
*/
public void delete() {
if (multipart) {
Iterator fileItemIter = fileItemMap.values().iterator();
while( fileItemIter.hasNext()) {
FileItem fileItem = (FileItem)fileItemIter.next();
fileItem.delete();
}
}
}
/**
* 래퍼객체 자체를 request 객체에 저장합니다.
*/
public void addTo() {
super.setAttribute(UploadSaveManager.class.getName(), this);
}
/**
* request 속성에 저장된 FileUploadRequestWrapper를 리턴합니다.
* @param request
* @return
*/
public static UploadSaveManager getFrom(HttpServletRequest request) {
return (UploadSaveManager)request.getAttribute(UploadSaveManager.class.getName());
}
/**
* 지정한 request가 래퍼를 속성으로 포함하고 있으면 true를 리턴합니다.
* @param request
* @return
*/
public static boolean hasWrapper(HttpServletRequest request) {
if (UploadSaveManager.getFrom(request) == null) {
return false;
} else {
return true;
}
}
// fileItem: 전송된 파일객체
// upDir: 저장할 디렉토리
public static String saveFile(FileItem fileItem, String upDir){
String filename = ""; //업로드 파일명
// 파일 태그
System.out.println("전송된 파일명: " + fileItem.getName());
// 폴더 구분자 추출
int idx = fileItem.getName().lastIndexOf("\\"); //윈도우 기반
if (idx == -1) { // 유닉스, 리눅스 기반
idx = fileItem.getName().lastIndexOf("/");
}
// 순수 파일명 추출
filename = fileItem.getName().substring(idx + 1);
try {
//-----------------------------------------------
//대상 폴더에 저장할 파일 객체 생성, 폴더 + 파일명
//-----------------------------------------------
File uploadedFile = new File(upDir, filename);
//올릴려는 파일과 같은 이름이 존재하면 중복파일 처리
if ( uploadedFile.exists() == true ){
for(int k=0; true; k++){
// 파일명 중복을 피하기 위한 일련 번호를 생성하여
// 파일명으로 조합
uploadedFile = new File(upDir, "("+k+")"+filename);
// 조합된 파일명이 존재하지 않는다면, 일련번호가
// 붙은 파일명 다시 생성
// 존재하지 않는 경우
// !을 이용해 false일 경우 참으로 처리되도록 변환
boolean bol = uploadedFile.exists();
if(bol == false){
// 존재하지 않는 새로운 파일명 확정
// (0)abc.txt
filename = "("+k+")"+filename;
break;
}
}
}
// storage 폴더에 파일명 저장
fileItem.write(uploadedFile);
} catch(Exception e) {
System.out.println(e.toString());
}
return filename; // 업로드된 파일명 리턴
}
//---------------------------------------------------------------
//Fileupload 콤포넌트 관련 코드 끝
//---------------------------------------------------------------
/**
* 파일을 삭제합니다.
*/
public static boolean deleteFile(String folder, String fileName){
boolean ret = false;
try{
if ( fileName != null){ // 기존에 파일이 존재하는 경우 삭제
File file = new File(folder + "/" + fileName);
ret = file.delete();
}
}catch(Exception e){
e.printStackTrace();
}
return ret;
}
public HashMap getFileItemMap() {
return fileItemMap;
}
public void setFileItemMap(HashMap fileItemMap) {
this.fileItemMap = fileItemMap;
}
/**
* 전송받은 파일의 갯수를 리턴
* @return
*/
public int getFileCount(){
return this.fileItemMap.size();
}
// Spring
public static String saveFileSpring30(MultipartFile multipartFile, String basePath) {
// input form's parameter name
String fileName = "";
// original file name
String originalFileName = multipartFile.getOriginalFilename();
// file content type
String contentType = multipartFile.getContentType();
// file size
long fileSize = multipartFile.getSize();
System.out.println("fileSize: " + fileSize);
System.out.println("originalFileName: " + originalFileName);
InputStream inputStream = null;
OutputStream outputStream = null;
try {
if( fileSize > 0 ) { // 파일이 존재한다면
// 인풋 스트림을 얻는다.
inputStream = multipartFile.getInputStream();
File oldfile = new File(basePath, originalFileName);
if ( oldfile.exists()){
for(int k=0; true; k++){
//파일명 중복을 피하기 위한 일련 번호를 생성하여
//파일명으로 조합
oldfile = new File(basePath,"("+k+")"+originalFileName);
//조합된 파일명이 존재하지 않는다면, 일련번호가
//붙은 파일명 다시 생성
if(!oldfile.exists()){ //존재하지 않는 경우
fileName = "("+k+")"+originalFileName;
break;
}
}
}else{
fileName = originalFileName;
}
//make server full path to save
String serverFullPath = basePath + "\\" + fileName;
System.out.println("fileName: " + fileName);
System.out.println("serverFullPath: " + serverFullPath);
outputStream = new FileOutputStream( serverFullPath );
// 버퍼를 만든다.
int readBytes = 0;
byte[] buffer = new byte[8192];
while((readBytes = inputStream.read(buffer, 0, 8192)) != -1 ) {
outputStream.write( buffer, 0, readBytes );
}
outputStream.close();
inputStream.close();
}
} catch(Exception e) {
e.printStackTrace();
}finally{
}
return fileName;
}
}//class end
5) Utility.java
package net.utility;
import java.util.*;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.PixelGrabber;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.Random;
import java.util.StringTokenizer;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.swing.ImageIcon;
public class Utility {
// 서비스시에는 도메인으로 변경됨.
private static final String root = "/myweb"; //프로젝트이름
public static synchronized String getRoot() {
return root;
}
/**
* 2048 -> 2가 리턴됨
*
* @param filesize
* @return
*/
public static synchronized long toUnit(long filesize) {
long size = 0;
if (filesize > 1024) {
size = filesize / 1024; // KB
} else {
size = filesize / (1024 * 1024); // MB
}
return size;
}
/**
* 2048 -> 2 KB가 리턴됨
*
* @param filesize
* @return
*/
public static synchronized String toUnitStr(long filesize) {
String size = "";
if (filesize > 1024) {
size = filesize / 1024 + " KB"; // KB
} else {
size = filesize / (1024 * 1024) + " MB"; // MB
}
return size;
}
/**
* 오늘 날짜를 문자열로 리턴합니다.
*
* @return
*/
public static synchronized String getCalendarDay() {
String str = "";
Calendar cal = Calendar.getInstance();
str = "" + cal.get(Calendar.DATE); // 날짜
return str;
}
/**
* 2010-12-14 형식의 날짜를 리턴합니다.
*
* @return 2008-01-30 형식의 문자열 리턴
*/
public static synchronized String getDate() {
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
String date = sd.format(new Date());
// System.out.println(date);
return date;
}
/**
* 20101214 형식의 날짜를 리턴합니다.
*
* @return 20101214 형식의 문자열 리턴
*/
public static synchronized String getDate2() {
SimpleDateFormat sd = new SimpleDateFormat("yyyyMMdd");
String date = sd.format(new Date());
// System.out.println(date);
return date;
}
/**
* 20101214 형식의 날짜를 리턴합니다.
*
* @param _date
* @return
*/
public static synchronized String getDate3(Date _date) {
SimpleDateFormat sd = new SimpleDateFormat("yyyyMMdd");
String date = sd.format(_date);
// System.out.println(date);
return date;
}
/**
* 2010년 12월 14일 형식의 날짜를 리턴합니다.
*
* @return
*/
public static synchronized String getDate4() {
SimpleDateFormat sd = new SimpleDateFormat("yyyy년 MM월 dd일");
String date = sd.format(new Date());
// System.out.println(date);
return date;
}
/**
* 20101214일 형식의 날짜를 리턴합니다.
*
* @param _date
* @return
*/
public static synchronized String getDate5(Date _date) {
SimpleDateFormat sd = new SimpleDateFormat("yyyyMMdd");
String date = sd.format(_date);
// System.out.println(date);
return date;
}
/**
* 2010-12-14 형식의 날짜를 리턴합니다.
*
* @return 2008-01-30 형식의 문자열 리턴
*/
public static synchronized String getDate6(int year, int month, int day) {
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
new Date();
String date = sd.format(new Date(year - 1900, month, day));
// System.out.println(date);
return date;
}
/**
* 내용중에 특수문자 표현을 위해 HTML 특수문자로 변환합니다.
* 예) 테이블 태그
* <TABLE> -> <TABLE>
*/
public static synchronized String convertChar(String str) {
str = str.replaceAll("<", "<");
str = str.replaceAll(">", ">");
str = str.replaceAll("'", "'"); // '
str = str.replaceAll("\"", ""s;"); // "
str = str.replaceAll("\r\n", "<BR>"); // 라인 변경
return str;
}
public static synchronized String convertCharTA(String str) {
str = str.replaceAll("<", "<");
str = str.replaceAll(">", ">");
str = str.replaceAll("'", "'"); // '
str = str.replaceAll("\"", ""s;"); // "
return str;
}
public static synchronized String getString(HttpServletRequest request, String variable) {
String value = "";
variable = request.getParameter(variable);
if (variable != null) {
variable = variable.trim();
if (variable.length() > 0) {
value = variable;
}
} else {
value = variable;
}
return value;
}
public static synchronized int getInt(HttpServletRequest request, String variable) {
int value = 0;
variable = request.getParameter(variable);
if (variable != null) {
variable = variable.trim();
if (variable.length() > 0) {
value = Integer.parseInt(variable);
}
} else {
value = 0;
}
return value;
}
// 줄 바꾸기
public static synchronized String getConvertCharTextArea(String str) {
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == '&') {
str = str.substring(0, i) + "&" + str.substring(i + 1, str.length());
}
}
return str;
}
public static synchronized String convertToDBMSforTextArea(String str) {
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == '<') {
str = str.substring(0, i) + "<" + str.substring(i + 1, str.length());
} else if (str.charAt(i) == '>') {
str = str.substring(0, i) + ">" + str.substring(i + 1, str.length());
}
}
return str;
}
public static synchronized String convertToHTMLforTextArea(String str) {
str.replaceAll("<", "<");
str.replaceAll(">", ">");
return str;
}
/**
* 로그인한 관리자 인지 검사
*
* @param session
* @return
*/
public static synchronized boolean isAdmin(HttpServletRequest request) {
boolean sw = false;
HttpSession session = request.getSession();
String s_id = Utility.checkNull((String) session.getAttribute("s_id"));
// System.out.println("현재 로그인 관리자 s_id: " + s_id);
if (s_id.equals("") == true) { // 로그인하지 않은 경우
sw = false;
} else {
sw = true;
}
return sw;
}
/**
* 로그인한 사용자인지 검사
*
* @param request
* @return
*/
public static synchronized boolean isMember(HttpServletRequest request) {
boolean sw = false;
HttpSession session = request.getSession();
String s_member_id = Utility.checkNull((String) session
.getAttribute("s_member_id"));
// System.out.println("현재 로그인 사용자 s_member_id: " + s_member_id);
if (s_member_id.equals("") == true) { // 로그인하지 않은 경우
sw = false;
} else {
sw = true;
}
return sw;
}
/**
* 로그인한 사용자 인지 검사
*
* @param session
* @return
*/
public static synchronized boolean isUser(HttpServletRequest request) {
boolean sw = false;
HttpSession session = request.getSession();
String s_member_id = Utility.checkNull((String) session
.getAttribute("s_member_id"));
if (s_member_id.length() > 1) { // 로그인하지 않은 경우
sw = true;
} else {
sw = false;
}
return sw;
}
public static synchronized boolean checkImageFile(String filename) {
boolean sw = false;
if (filename != null) {
sw = filename.endsWith(".jpg") || filename.endsWith(".jpeg")
|| filename.endsWith(".gif") || filename.endsWith(".png")
|| filename.endsWith(".bmp");
}
return sw;
}
public static synchronized String getBrowser(HttpServletRequest request) {
String header = request.getHeader("User-Agent");
if (header.indexOf("MSIE") > -1) {
return "MSIE";
} else if (header.indexOf("Chrome") > -1) {
return "Chrome";
} else if (header.indexOf("Opera") > -1) {
return "Opera";
}
return "Firefox";
}
public static synchronized String getDisposition(String filename, String browser) {
String dispositionPrefix = "attachment;filename=";
String encodedFilename = null;
try {
if (browser.equals("MSIE")) {
encodedFilename = URLEncoder.encode(filename, "UTF-8").replaceAll(
"\\+", "%20");
} else if (browser.equals("Firefox")) {
encodedFilename =
"\"" + new String(filename.getBytes("UTF-8"), "8859_1") + "\"";
} else if (browser.equals("Opera")) {
encodedFilename =
"\"" + new String(filename.getBytes("UTF-8"), "8859_1") + "\"";
} else if (browser.equals("Chrome")) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < filename.length(); i++) {
char c = filename.charAt(i);
if (c > '~') {
sb.append(URLEncoder.encode("" + c, "UTF-8"));
} else {
sb.append(c);
}
}
encodedFilename = sb.toString();
} else {
System.out.println("Not supported browser");
}
} catch (Exception e) {
}
return dispositionPrefix + encodedFilename;
}
/**
* 임의의 정수를 리턴합니다.
*
* @param range
* 정수범위 0 ~ 범위-1
* @return 난수 리턴
*/
public static synchronized int random(int range) {
// 0 ~ range-1까지 산출됨.
int rnd = 0;
Random random = new Random();
rnd = random.nextInt(range);
return rnd;
}
public static synchronized Date getDate(String date) {
Date currentTime = new Date();
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
try {
currentTime = sd.parse(date);
} catch (Exception e) {
}
// System.out.println(date);
return currentTime;
}
public static synchronized String progress(String enddate) {
java.util.Date nowtime = new java.util.Date();
java.util.Date endtime = getDate(enddate);
// System.out.println("nowtime: " + nowtime.toLocaleString());
// System.out.println("endtime: " + nowtime.toLocaleString());
String progress = null;
if (nowtime.after(endtime) == true) {
progress = "종료";
} else {
progress = "진행";
}
return progress;
}
/**
* 천단위마다 컴마를 출력합니다.
*
* @param price
* 금액
* @return 컴마가 포함된 문자열
*/
public static synchronized String comma(int price) {
DecimalFormat comma = new DecimalFormat("###,##0");
String cs = comma.format(price);
return cs;
}
public static synchronized String comma(long price) {
DecimalFormat comma = new DecimalFormat("###,##0");
String cs = comma.format(price);
return cs;
}
/**
* null 문자를 공백 문자로 변경합니다.
*
* @param str
* 검사할 문자열
* @return null 값을 가지고 있는 객체는 공백 문자열로 리턴됨
*/
public static synchronized String checkNull(String str) {
if (str == null) {
return ""; // null 이면 빈공백으로 리턴
} else {
return str; // 원래의 문자열 리턴
}
}
/**
* request 객체에서 문자열을 추출합니다.
*
* @param request
* @param str
* 추출할 변수
* @return 변환된 문자열
*/
public static synchronized String checkNull(HttpServletRequest request, String str) {
String rstr = "";
if (request.getParameter(str) != null) {
rstr = request.getParameter(str);
} else {
rstr = "";
}
return rstr;
}
/**
* 문자열이 Object 타입으로 전송된 것을 null 처리
*
* @param str
* @return
*/
public static String checkNull(Object str) {
if ((String) str == null) {
return "";
} else {
return (String) str;
}
}
/**
* FileUpload 1.2 한글 변환
*
* @param str
* @return
*/
public static synchronized String getEncodFileUpload12(String str) {
String corean = null;
try {
corean = new String(str.getBytes("ISO-8859-1"), "UTF-8");
// corean= new String(str.getBytes("ISO-8859-1"), "KSC5601");
} catch (Exception e) {
return corean;
}
return corean;
}
/**
* MVC, Tomcat 7.0기반 JSP 페이지 한글 변환
*
* @param str
* @return
*/
public static synchronized String getEncodeMVC(String str) {
String corean = null;
try {
corean = new String(str.getBytes("ISO-8859-1"), "UTF-8");
// corean= new String(str.getBytes("ISO-8859-1"), "KSC5601");
} catch (Exception e) {
return corean;
}
return corean;
}
/**
* fileupload 1.2.2 한글 처리
*
* @param ko
* @return
*/
public static synchronized String fileupload122Enc(String ko) {
String corean = null;
try {
// corean= new String(ko.getBytes("8859_1"), "euc-kr");
corean = new String(ko.getBytes("ISO-8859-1"), "utf-8");
// corean= new String(ko.getBytes("8859_1"), "iso-8859-1");
// corean= new String(ko.getBytes("utf-8"), "8859_1");
// corean= new String(ko.getBytes("8859_1"), "KSC5601");
} catch (Exception e) {
return corean;
}
return corean;
}
/**
* fileupload 1.2.2 한글 처리
*
* @param ko
* @return
*/
public static synchronized String fileupload122DownEnc(String ko) {
// charsetTest(ko);
String corean = null;
try {
// corean= new String(ko.getBytes("iso-8859-1"), "euc-kr");
// corean= new String(ko.getBytes("iso-8859-1"), "utf-8");
// corean= new String(ko.getBytes("8859_1"), "iso-8859-1");
// corean= new String(ko.getBytes("utf-8"), "8859_1");
// corean= new String(ko.getBytes("iso-8859-1"), "KSC5601");
corean = new String(ko.getBytes("KSC5601"), "EUC-KR");
} catch (Exception e) {
return corean;
}
return corean;
}
public static synchronized String getType(String fileUrl) {
String type = "";
fileUrl = "file:" + fileUrl;
try {
URL u = new URL(fileUrl);
URLConnection uc = u.openConnection();
type = uc.getContentType();
} catch (Exception e) {
System.out.println(e.toString());
}
return type;
}
/**
* 주어진 문자셋의 문자코드를 변환합니다.
*
* @param ko
* @return
*/
public static synchronized String ko(String ko) {
String str = null;
try {
// corean= new String(ko.getBytes("8859_1"), "euc-kr");
// corean= new String(ko.getBytes("8859_1"), "utf-8");
// corean= new String(ko.getBytes("8859_1"), "iso-8859-1");
// corean= new String(ko.getBytes("8859_1"), "utf-8");
str = new String(ko.getBytes("8859_1"), "KSC5601");
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == ' ') {
str = str.substring(0, i) + "%20"
+ str.substring(i + 1, str.length());
i = i + 3;
}
}
} catch (Exception e) {
}
return str;
}
/**
* 내용중에 특수문자 표현을 위해 HTML 특수문자로 변환합니다.
*/
public static synchronized String getConvertBR(String str) {
return str.replace("\n", "<BR>");
}
/**
* 파일 Download시 한글 파일 인코딩
*
* @param str
* @return
*/
public static synchronized String getEncod(String str) {
try {
// resin UTF-8 로 지정
// str = java.net.URLEncoder.encode(str, "EUC-KR");
// str = java.net.URLEncoder.encode(str, "UTF-8");
str = java.net.URLEncoder.encode(str, "KSC5601");
} catch (Exception e) {
}
// System.out.println(str);
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == '+') {
str = str.substring(0, i) + "%20" + str.substring(i + 1, str.length());
i = i + 3;
}
}
// System.out.println("최종변환 형태: "+str);
return str;
}
/**
* Struts2 GET방식 한글 문자셋 인코딩
*
* @param str
* @return
*/
public static synchronized String getEncodGet(String str) {
try {
str = java.net.URLEncoder.encode(str, "EUC-KR");
// str = java.net.URLEncoder.encode(str, "UTF-8");
// str = java.net.URLEncoder.encode(str, "KSC5601");
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == '+') {
str = str.substring(0, i) + "%20"
+ str.substring(i + 1, str.length());
i = i + 3;
}
}
} catch (Exception e) {
}
return str;
}
/**
* 스트럿츠 자료실 한글 출력 메소드
*
* @param str
* @return
*/
public static synchronized String encodStruts2(String str) {
try {
// str = java.net.URLEncoder.encode(str, "EUC-KR");
// str = java.net.URLEncoder.encode(str, "UTF-8");
str = java.net.URLEncoder.encode(str, "KSC5601");
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == '+') {
str = str.substring(0, i) + "%20"
+ str.substring(i + 1, str.length());
i = i + 3;
}
}
} catch (Exception e) {
}
return str;
}
/**
* FCKEditor 2.6.8 한글 변환
*
* @param str
* @return
*/
public static synchronized String encodFCK268(String str) {
String corean = null;
try {
corean = new String(str.getBytes("ISO-8859-1"), "UTF-8");
// corean= new String(str.getBytes("ISO-8859-1"), "KSC5601");
} catch (Exception e) {
return corean;
}
return corean;
}
/**
* 파일을 삭제합니다.
*
* @param folder
* 파일이 저장된 폴더
* @param filename
* 삭제할 파일명
* @return true-삭제 성공, false-삭제 실패
*/
public static synchronized boolean deleteFile(String folder, String filename) {
boolean ret = false;
try {
if (filename != null) { // 기존에 파일이 존재하는 경우 삭제
File file = new File(folder + "/" + filename);
// 파일이 존재하는지 확인 후 삭제
if (file.exists()) {
ret = file.delete();
}
}
} catch (Exception e) {
e.printStackTrace();
}
return ret;
}
/**
* application이름을 입력받아 절대 경로를 산출합니다. 예) getRealPath(request, "WEB-INF/config")
*
* @param request
* @param dir
* application 이름
* @return 절대 경로 리턴
* @throws IOException
*/
public static synchronized String getRealPath(HttpServletRequest request, String dir) {
// ByteArrayOutputStream baos = new ByteArrayOutputStream();
String path = "";
try{
path = request.getRealPath(dir) + "/";
System.out.println("Upload path: " + path);
}catch(Exception e){
System.out.println(e.toString());
}
return path;
}
/**
* 한글 변환 코드를 찾는 기능을 지원
*
* @param s
*/
public static synchronized void charsetTest(String s) {
try {
String[] charset = { "EUC-KR", "KSC5601", "ISO-8859-1", "8859_1",
"ASCII", "UTF-8" };
for (int i = 0; i < charset.length; i++) {
for (int j = 0; j < charset.length; j++) {
if (i == j)
continue;
System.out.print(charset[i] + " -> " + charset[j] + " : ");
System.out.println(new String(s.getBytes(charset[i]), charset[j]));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* null 문자를 숫자 0으로 변경합니다.
*
* @param request
* request 객체
* @param str
* 검사할 문자열
* @return 숫자를 리턴
*/
public static synchronized int checkInt(HttpServletRequest request, String str) {
int su = 0;
if (request.getParameter(str) != null) {
su = Integer.parseInt(request.getParameter(str));
}
return su;
}
public static int checkInt(String str) {
int su = 0;
if (str != null) {
su = Integer.parseInt(str);
}
return su;
}
/**
* null 문자를 숫자 0으로 변경합니다.
*
* @param request
* request 객체
* @param str
* 검사할 문자열
* @return 숫자를 리턴
*/
public static synchronized int checkAttrInt(HttpServletRequest request, String str) {
int su = 0;
if (request.getAttribute(str) != null) {
Integer itg = (Integer) (request.getAttribute(str));
su = itg.intValue();
}
return su;
}
/**
* Ajax 한글 변환
*
* @param ko
* @return
*/
public static synchronized String koAjax(String ko) {
String corean = null;
try {
// corean= new String(ko.getBytes("ISO-8859-1"), "UTF-8");
corean = new String(ko.getBytes("KSC5601"), "EUC-KR");
} catch (Exception e) {
return corean;
}
return corean;
}
/**
* 자바스크립트 특수문자, 줄바꿈 문자 변환
*
* @param str
* @return
*/
public static synchronized String toJS(String str) {
if (str != null) {
return str.replace("\\", "\\\\").replace("\'", "\\\'")
.replace("\"", "\\\"").replace("\r\n", "\\n").replace("\n", "\\n");
} else {
return "";
}
}
/**
* Ajax 한글 변환
*
* @param ko
* @return
*/
public static synchronized String koAndroid(String ko) {
String corean = null;
try {
// corean= new String(ko.getBytes("UTF-8"), "EUC-KR");
// corean= new String(ko.getBytes("ISO-8859-1"), "UTF-8");
// corean= new String(ko.getBytes("KSC5601"), "EUC-KR");
corean = new String(ko.getBytes("8859_1"), "UTF-8");
} catch (Exception e) {
return corean;
}
return corean;
}
/**
* 문자열 경로를 받아 모든 파일 목록을 리턴
*
* @param dir
* @return
*/
public static synchronized String[] fileNameList(String dir) {
File sdDir = null;
String[] str = null;
try {
// Check SD Card mount.
sdDir = new File("."); // /sdcard
// 존재/쓰기 여부 확인
if (sdDir.exists() && sdDir.canWrite()) {
File _dir = new File(dir);
if (_dir.exists() && _dir.canRead()) {
str = _dir.list();
}
}
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
/**
* 파일 객체를 받아 파일 목록을 리턴
*
* @param dir
* @return
*/
public static synchronized String[] fileNameList(File dir) {
String[] str = null;
try {
str = dir.list();
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
/**
* 파일 목록에서 확장자를 제거함
*
* @param str
* @return
*/
public static synchronized ArrayList convertFilenameNotExtend(String[] str) {
ArrayList retVal = new ArrayList();
;
for (int i = 0; i < str.length; i++) {
int point = str[i].indexOf(".");
retVal.add(str[i].substring(0, point));
}
return retVal;
}
/**
* 파일에서 확장자를 제거함. 예) data.txt --> data
*
* @param str
* @return
*/
public static synchronized String convertFilenameNotExtend(String str) {
String noExt = "";
int point = str.indexOf(".");
noExt = str.substring(0, point);
return noExt;
}
// 폴더를 생성
public static synchronized void makeFolder(String _dir) {
File sdDir = null; // 폴더명
File dir = null;
sdDir = new File(".");
dir = new File(sdDir.toString() + "/" + _dir);
if (sdDir.exists() && sdDir.canWrite()) {
if (dir.exists() == false) {
dir.mkdir();
}
}
}
public static synchronized String onlyFilename(String _str) {
// /sdcard/smartalbum/20101201_090101.jpg
int ps = _str.lastIndexOf("/");
// System.out.println("ps: " + ps);
String str = _str.substring(ps + 1); // 20101201_090101.jpg
int pd = str.lastIndexOf(".");
System.out.println("pd: " + pd);
str = str.substring(0, pd);
return str;
}
public static synchronized String convertFilename(String str) {
// 20101201_090101
// 012345678901234
// 2010년 12월 1일 09시 01분 01초
String year = str.substring(0, 4);
String month = str.substring(4, 6);
String day = str.substring(6, 8);
String hour = str.substring(9, 11);
String minute = str.substring(11, 13);
String second = str.substring(13);
String _str = year + "년 " + month + "월 " + day + "일 " + hour + "시 "
+ minute + "분 " + second + "초 ";
return _str;
}
/**
* 파일 삭제
* @param fname
* @return
*/
public static synchronized boolean deleteFile(String fname) {
File file = new File(fname);
boolean ret = false;
if (file.exists()){
ret = file.delete();
}
return ret;
}
/**
* 바이트배열로 되어 있는 문자열을 받아 원래의 문자열로 변환
*
* @param str
* @return
*/
public static synchronized String byteToString(String str) {
String retVal = "";
try {
StringTokenizer st = new StringTokenizer(str, ",");
byte[] _str = new byte[st.countTokens()];
int i = -1;
while (st.hasMoreTokens()) {
i++;
_str[i] = Byte.parseByte(st.nextToken());
}
retVal = new String(_str, 0, _str.length, "UTF-8");
} catch (Exception e) {
}
return retVal;
}
/**
* 문자열을 바이트 배열 문자열로 변환
*
* @param str
* @return
*/
public static synchronized String stringToByte(String str) {
String deli = ","; // 구분자
String retVal = "";
try {
byte[] bstr = str.getBytes("UTF-8");
for (int i = 0; i < bstr.length; i++) {
retVal = retVal + deli + bstr[i];
}
} catch (Exception e) {
}
return retVal;
}
/**
* 현재 시간을 1970년 1월 1일부터 수치형식으로 리턴
*
* @return
*/
public static synchronized long getTimeNumber() {
long time = System.currentTimeMillis();
return time;
}
/**
* 주어진 시간을 1970년 1월 1일부터 수치형식으로 리턴
*
* @return
*/
public static synchronized long getTimeNumber(String date) {
Date _date = new Date();
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
try {
_date = sd.parse(date);
} catch (Exception e) {
}
// System.out.println(date);
long time = _date.getTime();
return time;
}
/**
* 주어진 날짜와 기간을 계산하여 새글 여부 판단 현재 날짜가 2013-02-04 글을 등록날짜 2013-02-02
* getTimeNew("2013-02-04", 2) : 새글 처리, true getTimeNew("2013-02-04", 3) : 새글
* 처리, false
*
* @param date
* 문자열로 된 날짜
* @param period
* 새글로 지정할 기간
* @return
*/
public static synchronized boolean getTimeNew(String date, int period) {
boolean sw = false;
Date _date = new Date();
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
try {
_date = sd.parse(date);
} catch (Exception e) {
}
// System.out.println(date);
// 1970년1월1일부터 시간을 1000을 1초로하여 계산하여 리턴
long time = _date.getTime(); // 글을 작성한 시간
// 현재 시간을 1970년 1월 1일부터 수치형식으로 리턴
long currentTime = System.currentTimeMillis();
// 현재 시간과 글 등록시간의 차이를 계산
long diff = currentTime - time;
// 1일 86,400,000: 1초를 1000으로 하루를 계산
// 0.0001 --> 1: 오늘 날짜
// 1.00002 --> 2: 어제 날짜
int day = (int) Math.ceil(((double) diff / 86400000));
if (day <= period) {
sw = true; // 최신글 처리
}
return sw;
}
/**
* 이미지 사이즈를 변경하여 새로운 이미지를 생성합니다. 원본 이미지는 축소후 삭제합니다.
*
* @param dir
* 기준 폴더
* @param _src
* 원본 이미지
* @param width
* 생성될 이미지 너비
* @param height
* 생성될 이미지 높이, ImageUtil.RATIO는 자동 비례 비율
* @throws IOException
*/
public static synchronized String imgResize(String dir, String filename, int width,
int height) throws IOException {
File src = new File(dir + "/" + filename);
File dest = new File(dir + "/" + Utility.convertFilenameNotExtend(filename)
+ "_s.jpg");
int RATIO = 0;
int SAME = -1;
Image srcImg = null;
// 파일의 확장자 추출
String suffix = src.getName().substring(src.getName().lastIndexOf('.') + 1)
.toLowerCase();
// 이미지의 확장자를 검색하여 이미지 파일인지 검사
if (suffix.equals("jpg") || suffix.equals("bmp") || suffix.equals("png")
|| suffix.equals("gif")) {
srcImg = ImageIO.read(src); // 메모리에 이미지 생성
} else {
srcImg = new ImageIcon(src.getAbsolutePath()).getImage();
}
int srcWidth = srcImg.getWidth(null); // 원본 이미지 너비 추출
int srcHeight = srcImg.getHeight(null); // 원본 이미지 높이 추출
int destWidth = -1, destHeight = -1; // 대상 이미지 크기 초기화
if (width == SAME) { // 너비가 같은 경우
destWidth = srcWidth;
} else if (width > 0) {
destWidth = width;
}
if (height == SAME) { // 높이가 같은 경우
destHeight = srcHeight;
} else if (height > 0) {
destHeight = height;
}
// 비율에 따른 크기 계산
if (width == RATIO && height == RATIO) {
destWidth = srcWidth;
destHeight = srcHeight;
} else if (width == RATIO) {
double ratio = ((double) destHeight) / ((double) srcHeight);
destWidth = (int) ((double) srcWidth * ratio);
} else if (height == RATIO) {
double ratio = ((double) destWidth) / ((double) srcWidth);
destHeight = (int) ((double) srcHeight * ratio);
}
// 메모리에 대상 이미지 생성
Image imgTarget = srcImg.getScaledInstance(destWidth, destHeight,
Image.SCALE_SMOOTH);
int pixels[] = new int[destWidth * destHeight];
PixelGrabber pg = new PixelGrabber(imgTarget, 0, 0, destWidth, destHeight,
pixels, 0, destWidth);
try {
pg.grabPixels();
} catch (InterruptedException e) {
throw new IOException(e.getMessage());
}
BufferedImage destImg = new BufferedImage(destWidth, destHeight,
BufferedImage.TYPE_INT_RGB);
destImg.setRGB(0, 0, destWidth, destHeight, pixels, 0, destWidth);
// 파일에 기록
ImageIO.write(destImg, "jpg", dest);
System.out.println(dest.getName() + " 이미지를 생성했습니다.");
// 원본 파일 삭제
boolean ret = Utility.deleteFile(dir + "/" + filename);
if (ret == true) {
System.out.println("파일을 삭제 했습니다.: " + filename);
}
return dest.getName();
}
/**
* 이미지 사이즈를 변경하여 새로운 이미지를 생성합니다.
*
* @param src
* 원본 이미지
* @param dest
* 생성되는 이미지
* @param width
* 생성될 이미지 너비
* @param height
* 생성될 이미지 높이, ImageUtil.RATIO는 자동 비례 비율
* @throws IOException
*/
public static synchronized String imgResize(File src, File dest, int width, int height)
throws IOException {
int RATIO = 0;
int SAME = -1;
Image srcImg = null;
// 파일의 확장자 추출
String suffix = src.getName().substring(src.getName().lastIndexOf('.') + 1)
.toLowerCase();
// 이미지의 확장자를 검색하여 이미지 파일인지 검사
if (suffix.equals("jpg") || suffix.equals("bmp") || suffix.equals("png")
|| suffix.equals("gif")) {
srcImg = ImageIO.read(src); // 메모리에 이미지 생성
} else {
srcImg = new ImageIcon(src.getAbsolutePath()).getImage();
}
int srcWidth = srcImg.getWidth(null); // 원본 이미지 너비 추출
int srcHeight = srcImg.getHeight(null); // 원본 이미지 높이 추출
int destWidth = -1, destHeight = -1; // 대상 이미지 크기 초기화
if (width == SAME) { // 너비가 같은 경우
destWidth = srcWidth;
} else if (width > 0) {
destWidth = width;
}
if (height == SAME) { // 높이가 같은 경우
destHeight = srcHeight;
} else if (height > 0) {
destHeight = height;
}
// 비율에 따른 크기 계산
if (width == RATIO && height == RATIO) {
destWidth = srcWidth;
destHeight = srcHeight;
} else if (width == RATIO) {
double ratio = ((double) destHeight) / ((double) srcHeight);
destWidth = (int) ((double) srcWidth * ratio);
} else if (height == RATIO) {
double ratio = ((double) destWidth) / ((double) srcWidth);
destHeight = (int) ((double) srcHeight * ratio);
}
// 메모리에 대상 이미지 생성
Image imgTarget = srcImg.getScaledInstance(destWidth, destHeight,
Image.SCALE_SMOOTH);
int pixels[] = new int[destWidth * destHeight];
PixelGrabber pg = new PixelGrabber(imgTarget, 0, 0, destWidth, destHeight,
pixels, 0, destWidth);
try {
pg.grabPixels();
} catch (InterruptedException e) {
throw new IOException(e.getMessage());
}
BufferedImage destImg = new BufferedImage(destWidth, destHeight,
BufferedImage.TYPE_INT_RGB);
destImg.setRGB(0, 0, destWidth, destHeight, pixels, 0, destWidth);
// 파일에 기록
ImageIO.write(destImg, "jpg", dest);
System.out.println(dest.getName() + " 이미지를 생성했습니다.");
return dest.getName();
}
/**
* FileUpload 1.2 한글 변환
*
* @param str
* @return
*/
public static synchronized String encodFileUpload12(String str) {
String corean = null;
try {
corean = new String(str.getBytes("ISO-8859-1"), "UTF-8");
// corean= new String(str.getBytes("ISO-8859-1"), "KSC5601");
} catch (Exception e) {
return corean;
}
return corean;
}
/**
* 이미지인지 검사
* @param filename
* @return
*/
public static synchronized boolean isImage(String filename) {
boolean sw = false;
if (filename != null) {
filename = filename.toLowerCase();
sw = filename.endsWith(".jpg") || filename.endsWith(".jpeg")
|| filename.endsWith(".gif") || filename.endsWith(".png")
|| filename.endsWith(".bmp");
}
return sw;
}
public static synchronized String trim(String str, int length) {
String _str = "";
if (str.length() > length) {
_str = str.substring(0, length);
} else {
_str = str;
}
return _str;
}
}//class end
2. WEB-INF
spring
1) 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"
xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Root Context: defines shared resources visible to all other web components -->
</beans>
spring > appServlet
1) servlet-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<!-- <resources mapping="/resources/**" location="/resources/" /> -->
<default-servlet-handler/> <!-- myweb 형식 잊지말기 !!!! l -->
<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
<!-- File 전송이 있는 경우 Spring 등록 l -->
<!-- CommonsMultipartResolver -->
<!-- id 소문자로...해야한다..... -->
<beans:bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</beans:bean>
<context:component-scan base-package="kr.co.mymelon" />
</beans:beans>
views
1) web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- filer (한글) l -->
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
3. pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>kr.co</groupId>
<artifactId>form1</artifactId>
<name>BasicAjax</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.6</java-version>
<org.springframework-version>3.1.1.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.14</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.
sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.5</version>
</dependency>
<!-- pom.xml 외부라이브러리 다운 External Library -->
<!-- User가 필요한 Library Download -->
<!-- begin -->
<!-- Java Mail Library -->
<!-- https://mvnrepository.com/artifact/javax.mail/mail -->
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>1.4.7</version>
</dependency>
<!-- File upload/download 관련 Library -->
<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.3</version>
</dependency>
<!-- JSON Library -->
<!-- https://mvnrepository.com/artifact/com.googlecode.json-simple/json-simple -->
<dependency>
<groupId>com.googlecode.json-simple</groupId>
<artifactId>json-simple</artifactId>
<version>1.1.1</version>
</dependency>
<!-- Spring JDBC Template Library -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<!-- mybatis -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.2</version>
</dependency>
<!-- MySQL Library -->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version>
</dependency>
<!-- Oracle Library -->
<!-- 저장소 위치를 별도로 지정해야한다. build 아래에 -->
<!-- https://mvnrepository.com/artifact/com.oracle/ojdbc6 -->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>12.1.0.1-atlassian-hosted</version>
<!-- <scope>test</scope> -->
</dependency>
<!-- end -->
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
<!-- Oracle 저장소 별도지정 위치 l -->
<repositories>
<repository>
<id>oracle</id>
<url>https://repo.spring.io/plugins-release/</url>
</repository>
</repositories>
</project>
'Backend' 카테고리의 다른 글
| 코드로 배우는 Spring Web 프로젝트 Ⅰ (0) | 2019.12.02 |
|---|---|
| 과정평가형 예상문제 - 커피판매관리 프로그램 (1) | 2019.10.21 |
| 10월 16일 수 | SPRING 02 - 스프링 프로젝트 MAVEN (0) | 2019.10.15 |
| 10월 14일 월 | SPRING 01 - 스프링 프로젝트 시작하기 (0) | 2019.10.14 |
| 10월 02일 수 | JSP 19 - MyController (0) | 2019.10.02 |
댓글