BS Blog: programing

레이블이 programing인 게시물을 표시합니다. 모든 게시물 표시

2012-10-31

java Framework/jsp 프로그래밍/common.net을 이용한 FTP client 프로그램

소스영역 :::

/**
* 참조 사이트 목록
* http://www.okjsp.pe.kr/seq/51685
* http://benelog.springnote.com/pages/1468338
* 참조해서 작업 해 본것임.
* apache 의 common.net api 사용
* ftp batch 작업을 위한 용도
* 2009.03.26
* 인자 : -H:server ip, -P:server port, -UI:user id, -UP:user pw, -PM:passive-mode
*/
package net.nchannel.ftp;
/**
* @author snipper
*
*/
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.*;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
//import org.apache.commons.net.ftp.FTPListParseEngine;
//import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.Logger;

public class FCBatch {
//    protected static final Log logger = LogFactory.getLog(FCBatch.class);
/**
*
*/
    public FCBatch() {
  // TODO Auto-generated constructor stub
}
/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  // 인자는 -H, -P, -ui, -up, -path, -pm 이 존재
  String host = "";
  String port = "";
  String id = "";
  String pw = "";
  String rpath = "";
  String pm = "";
  String fileNm = "";   //"JeusServer_"+getDate(-1)+".log"; //현재 이전 날짜의 파일 가져오기 위한 파일명 구하기
  String lpath = "";    //"d:\\jeuslogs\\JeusServer_"+getDate(-1)+".log"; //현재 이전 날짜의 파일 가져오기 위한 파일명 구하기
  FileOutputStream fos = null;

//  System.out.println("입력 인자 수 : " + args.length);
//  System.out.println("파일 명 : " + fileNm);
  // 입력된 인자 값을 각 의미 변수에 할당.
  for(int i=0; i < args.length; i++) {
   if(args[i].indexOf("-H")!=-1)
    host = args[i].substring(2);
   if(args[i].indexOf("-P")!=-1)
    port = args[i].substring(2);
   if(args[i].indexOf("-UI")!=-1)
    id = args[i].substring(3);
   if(args[i].indexOf("-UP")!=-1)
    pw = args[i].substring(3);
   if(args[i].indexOf("-RP")!=-1)
    rpath = args[i].substring(3);
   if(args[i].indexOf("-LP")!=-1)
    lpath = args[i].substring(3);
   if(args[i].indexOf("-FN")!=-1)
    fileNm = args[i].substring(3);
   if(args[i].indexOf("-PM")!=-1)
    pm = args[i].substring(3);
  }
  if(port.equals("")) port = "21"; //접속 포트 번호, 기본 21번 포트 사용
  if(rpath.equals("")) rpath = "/home/tmax/jeus5/logs/ECOWEB/"; //원격 기본 디렉토리 설정, 제우스를 기본으로 했음.
  if(lpath.equals("")) lpath = "c:\\jeuslogs\\";      //로컬 기본 디렉토리 설정, 로컬 디렉토리가 없을 경우.... 현재 폴더로 해도 되나 그냥 위와 같이 함.
  if(fileNm.equals("")) fileNm = "JeusServer_"+getDate(-1)+".log"; //가져올 기본 파일명 설정
  if(pm.equals("")) pm = "Y"; // 패시브모드 on(기본모드)
//  System.out.println("host = " + host);
//  System.out.println("port = " + port);
//  System.out.println("id = " + id);
//  System.out.println("pw = " + pw);
//  System.out.println("remote path = " + rpath);
//  System.out.println("local path = " + lpath);
//  System.out.println("file name = " + fileNm);
//  System.out.println("passive mode y/n = " + pm);

  FTPClient ftp = null;

  try {
   ftp = new FTPClient();
   ftp.setControlEncoding("euc-kr"); // ftp 인코딩을 EUC-KR 로 설정.

//   if(logger.isDebugEnabled()) {
    System.out.println("FTP Client Test Progrma with Commons NET");
    System.out.println("test by 2009.03.26");
    System.out.println("FCBatch main() start");
//    System.out.println("host = " + host);
//    System.out.println("port = " + port);
//    System.out.println("id = " + id);
//    System.out.println("pw = " + pw);
//    System.out.println("remote path = " + rpath);
//    System.out.println("passive mode y/n = " + pm);
//   }
//

   if(!host.equals("") && !port.equals("") && !id.equals("") && !pw.equals("")) {
    // ftp 연결
    ftp.connect(host,Integer.parseInt(port));
//    if(logger.isDebugEnabled()) {
     System.out.println("connected to " + host +":"+port);
//    }
//    if(logger.isDebugEnabled()) {
     System.out.println("login by user id : " + id +", password :"+pw);
     System.out.println("ftp.login()");
//    }
    ftp.login(id, pw);
//    if(logger.isDebugEnabled()) {
     System.out.println("login success...");
//    }

    // 패시브 모드 설정 하기
    if(pm.endsWith("Y")) {
//     if(logger.isDebugEnabled()){
      System.out.println("passive mode 설정");
      System.out.println("passive mode 입력 값: " +pm);
//     }
     ftp.enterLocalPassiveMode();
//     if(logger.isDebugEnabled()){
      System.out.println("passive mode 설정 완료");
//     }
    }

    //change directory
//    if(logger.isDebugEnabled()) {
     System.out.println("change directory : " + rpath );
     System.out.println("ftp.changeWorkingDirectory("+rpath+")");
//    }
    ftp.changeWorkingDirectory(rpath);
//    if(logger.isDebugEnabled()) {
     System.out.println("경로 변경 : " + rpath);
//    }

//    if(logger.isDebugEnabled()) {
     System.out.println("파일 전송 타입 설정 : setFileType" );
     System.out.println("ftp.setFileType(FTP.BINARY_FILE_TYPE)");
//    }
    ftp.setFileType(FTP.BINARY_FILE_TYPE);
//    if(logger.isDebugEnabled()) {
     System.out.println("파일 전송 타입 설정 완료 " );
//    }

    // ftp 사이트 리스팅.
//    ftpList(ftp, path);
/*
    try{
//     if(logger.isDebugEnabled()) {
      System.out.println("서버 디렉토리 리스팅 : " );
      System.out.println("ftp.setFileType(FTP.BINARY_FILE_TYPE)");
//     }
     FTPListParseEngine engine = ftp.initiateListParsing("unix",path);
     System.out.println("" + StringUtils.rightPad("Name", 30) + StringUtils.leftPad("Size", 10) + " ");
     System.out.println("" + StringUtils.leftPad("-", 30, "-") + StringUtils.leftPad("-", 10,"-") + "-");

     int idx=0;

     while(engine.hasNext()) {
      FTPFile[] files = engine.getNext(25);
      idx += files.length;

      for(int i=0; i < files.length; i++) {
       FTPFile file= files[i];
       System.out.println(StringUtils.rightPad(" "+file.getName(),30) + StringUtils.leftPad(""+file.getSize(), 10) + " ");

      }
     }

     System.out.println("-" + StringUtils.leftPad("-", 30, "-") + StringUtils.leftPad("-", 10, "-") + "-");
     System.out.println(" total : " + idx);
     System.out.println(" ");

//     if(logger.isDebugEnabled()) {
      System.out.println("서버 디렉토리 리스팅 : " + path + "완료" );
//     }
    } catch (Exception e) {
     System.out.println("ftp 리스팅 실패");
     e.printStackTrace();
     System.exit(-1);
    }

*/
    // 파일 내려 받기 ??
    try {
     fos = new FileOutputStream(lpath+fileNm);
     ftp.retrieveFile(fileNm, fos);
    } catch(IOException e) {
     System.out.println("IO Exception : " + e.getMessage());
    } finally {
     if(fos != null) {
      try {
       fos.close();

      } catch (IOException e) {
       System.out.println("IO Exception : " + e.getMessage());
      }
     }
    }

    System.out.println(fileNm + "파일 다운로드 완료 !!!");

   } else { // host, port, id, pw 없으면 에러 발생.
    System.out.println("usage : FCBatch -Hhost -P[port] -UIid -UPpw -RP[remote path] -LP[local path] -FN[file name] -PM[passive mode] ");
    System.out.println("options ");
    System.out.println("-H : Host [Name | IP] ");
    System.out.println("-P : 접속할 포트 번호 ,     Default : 21 ");
    System.out.println("-UI : User ID ");
    System.out.println("-UP : User Password");
    System.out.println("-RP : FTP Server Path,   Default : /home/tmax/jeus5/logs/ECOWEB/");
    System.out.println("-LP : Localhost Path,    Default : c:\\jeuslogs\\");
    System.out.println("-FN : Download 할 File Name , Default : JeusServer_"+getDate(-1)+".log ");
    System.out.println("-PM : Passive Mode 사용 여부 [Y/N], Default: Y ");

//    throw new Exception("접속에 필요한 필수 정보를 입력하지 않으셨습니다.");
   }


  } catch (Exception e) {
//   System.out.println("ftp 로그인 실패");
   e.printStackTrace();
  } finally {
   // ftp 연결 해제.
//   System.out.println("ftp 연결해제");
   if(ftp != null && ftp.isConnected()) {
    try {
     ftp.disconnect();
    } catch (IOException e) {
     System.out.println("IOException : " + e.getMessage());
    }
   }
   // 프로그램 종료
   System.exit(-1); // 종료
  }

}
/*
public static void ftpList(FTPClient ftp, String path) {
  try{
   if(logger.isDebugEnabled()) {
    System.out.println("서버 디렉토리 리스팅 : " );
    System.out.println("ftp.setFileType(FTP.BINARY_FILE_TYPE)");
   }
   FTPListParseEngine engine = ftp.initiateListParsing("unix",path);
   System.out.println("" + StringUtils.rightPad("Name", 30) + StringUtils.leftPad("Size", 10) + " ");
   System.out.println("" + StringUtils.leftPad("-", 30, "-") + StringUtils.leftPad("-", 10,"-") + "-");

   int idx=0;

   while(engine.hasNext()) {
    FTPFile[] files = engine.getNext(25);
    idx += files.length;

    for(int i=0; i < files.length; i++) {
     FTPFile file= files[i];
     System.out.println(StringUtils.rightPad(" "+file.getName(),30) + StringUtils.leftPad(""+file.getSize(), 10) + " ");

    }
   }

   System.out.println("-" + StringUtils.leftPad("-", 30, "-") + StringUtils.leftPad("-", 10, "-") + "-");
   System.out.println(" total : " + idx);
   System.out.println();

   if(logger.isDebugEnabled()) {
    System.out.println("서버 디렉토리 리스팅 : " + path + "완료" );
   }
  } catch (Exception e) {
   System.out.println("ftp 리스팅 실패");
   e.printStackTrace();
   System.exit(-1);
  }

}
*/

/**
*
* @param day
* @return
*/
public static String getDate(int day){
  Calendar temp = Calendar.getInstance();
  StringBuffer sDate = new StringBuffer();

  temp.add(Calendar.DAY_OF_MONTH, -1);

  int iYY = temp.get(Calendar.YEAR);
  int iMM = temp.get(Calendar.MONTH)+1;
  int iDD = temp.get(Calendar.DAY_OF_MONTH);

  sDate.append(iYY);
  if(iMM <10)
   sDate.append("0");
  sDate.append(iMM);

  if(iDD < 10)
   sDate.append("0");
  sDate.append(iDD);

  return sDate.toString();
}
}

java Framework/JSP] taglib prefix=c 로 사용시 에러 발생하는 경우

출처 : http://ck1024.tistory.com/14

-<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>" 으로 작성을 했더니 아래의 에러가 발생
→ According to TLD or attribute directive in tag file, attribute value does not accept any expressions

"<%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %>"으로 수정하니 정상적으로 실행됨

Servlet 2.3
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>

Servlet 2.4
<%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %>

java Framework/jsp] 세션 공유시 서블릿 컨텍스트 참조 문제

원문 url : http://blog.daum.net/uttiboy/16864082

세션 공유시 서블릿 컨텍스트 참조 문제

두 웹애플리케이션에서 세션을 공유할때 세션을 통해 서블릿 컨텍스트를 참조할때

어떤 서블릿 컨텍스트를 참조할까?

Root WebApp - xxx.co.kr

WebApp1 - xxx.co.kr/app1

두 애플리케이션은 서로 세션공유가 가능하도록 설정되어 있다

이때 xxx.co.kr로 접근하고 xxx.co.kr/app1으로 접근할때 두 애플리케이션간에

세션은 공유되어 있다.

문제는 WebApp1에서 session.getServletContext()를 호출할때 어떤 서블릿 컨텍스트가 반환될까?

애플리케이션의 접근 순서에 따라 다른데 xxx.co.kr을 접근하고 xxx.co.kr로 접근하게되면

xxx.co.kr에서 세션이 생성되고 Root WebApp의 서블릿 컨텍스트를 참조하게 되어서

WebApp1에서 session.getServletContext()는 xxx.co.kr의 서블릿 컨텍스트를 참조한다.

WebApp1에서 자신의 서블릿 컨텍스트를 참조하기 위해서는 session.getServletContext().getContext("/app1")으로 참조해야 한다.

Tomcat의 경우 context에 crossContext 속성을 true로 설정해야 가능하다고 합니다

java Framework/java]Reading and writing text files

출처 : http://www.javapractices.com/topic/TopicAction.do?Id=42

Reading and writing text files

When reading and writing text files :

it's almost always a good idea to use buffering (default size is 8K)
it's often possible to use references to abstract base classes, instead of references to specific concrete classes
there is always a need to pay attention to exceptions (in particular, IOException and FileNotFoundException)

The close method :

always needs to be called, or else resources will leak
will automatically flush the stream, if necessary
calling close on a "wrapper" stream will automatically call close on its underlying stream
closing a stream a second time has no consequence

Commonly used items :

Scanner - allows reading files in a compact way
BufferedReader - readLine
BufferedWriter - write + newLine

The FileReader and FileWriter classes are a bit tricky, since they implicitly use the system's default character encoding. If this default is not appropriate (for example, when reading an XML file which specifies its own encoding), the recommended alternatives are, for example :
FileInputStream fis = new FileInputStream("test.txt");
InputStreamReader in = new InputStreamReader(fis, "UTF-8");
FileOutputStream fos = new FileOutputStream("test.txt");
OutputStreamWriter out = new OutputStreamWriter(fos, "UTF-8");
Scanner scanner = new Scanner(file, "UTF-8");
The following examples use JDK 1.5.
Example 1
Here is a fairly compact example of reading and writing a text file, using an explicit encoding. If you remove all references to encoding from this class, it will still work -- the system's default encoding will simply be used instead.

import java.io.*;
import java.util.Scanner;

/** 
 Read and write a file using an explicit encoding.
 Removing the encoding from this code will simply cause the 
 system's default encoding to be used instead.  
*/
public final class ReadWriteTextFileWithEncoding {

  /** Requires two arguments - the file name, and the encoding to use.  */
  public static void main(String... aArgs) throws IOException {
    String fileName = aArgs[0];
    String encoding = aArgs[1];
    ReadWriteTextFileWithEncoding test = new ReadWriteTextFileWithEncoding(
      fileName, encoding
    );
    test.write();
    test.read();
  }
  
  /** Constructor. */
  ReadWriteTextFileWithEncoding(String aFileName, String aEncoding){
    fEncoding = aEncoding;
    fFileName = aFileName;
  }
  
  /** Write fixed content to the given file. */
  void write() throws IOException  {
    log("Writing to file named " + fFileName + ". Encoding: " + fEncoding);
    Writer out = new OutputStreamWriter(new FileOutputStream(fFileName), fEncoding);
    try {
      out.write(FIXED_TEXT);
    }
    finally {
      out.close();
    }
  }
  
  /** Read the contents of the given file. */
  void read() throws IOException {
    log("Reading from file.");
    StringBuilder text = new StringBuilder();
    String NL = System.getProperty("line.separator");
    Scanner scanner = new Scanner(new File(fFileName), fEncoding);
    try {
      while (scanner.hasNextLine()){
        text.append(scanner.nextLine() + NL);
      }
    }
    finally{
      scanner.close();
    }
    log("Text read in: " + text);
  }
  
  // PRIVATE 
  private final String fFileName;
  private final String fEncoding;
  private final String FIXED_TEXT = "But soft! what code in yonder program breaks?";
  
  private void log(String aMessage){
    System.out.println(aMessage);
  }
}

Example 2
This example uses FileReader and FileWriter, which implicitly use the system's default encoding. To make this example compatible with JDK 1.4, just change StringBuilder to StringBuffer:

import java.io.*;

public class ReadWriteTextFile {

  /**
  * Fetch the entire contents of a text file, and return it in a String.
  * This style of implementation does not throw Exceptions to the caller.
  *
  * @param aFile is a file which already exists and can be read.
  */
  static public String getContents(File aFile) {
    //...checks on aFile are elided
    StringBuilder contents = new StringBuilder();
    
    try {
      //use buffering, reading one line at a time
      //FileReader always assumes default encoding is OK!
      BufferedReader input =  new BufferedReader(new FileReader(aFile));
      try {
        String line = null; //not declared within while loop
        /*
        * readLine is a bit quirky :
        * it returns the content of a line MINUS the newline.
        * it returns null only for the END of the stream.
        * it returns an empty String if two newlines appear in a row.
        */
        while (( line = input.readLine()) != null){
          contents.append(line);
          contents.append(System.getProperty("line.separator"));
        }
      }
      finally {
        input.close();
      }
    }
    catch (IOException ex){
      ex.printStackTrace();
    }
    
    return contents.toString();
  }

  /**
  * Change the contents of text file in its entirety, overwriting any
  * existing text.
  *
  * This style of implementation throws all exceptions to the caller.
  *
  * @param aFile is an existing file which can be written to.
  * @throws IllegalArgumentException if param does not comply.
  * @throws FileNotFoundException if the file does not exist.
  * @throws IOException if problem encountered during write.
  */
  static public void setContents(File aFile, String aContents)
                                 throws FileNotFoundException, IOException {
    if (aFile == null) {
      throw new IllegalArgumentException("File should not be null.");
    }
    if (!aFile.exists()) {
      throw new FileNotFoundException ("File does not exist: " + aFile);
    }
    if (!aFile.isFile()) {
      throw new IllegalArgumentException("Should not be a directory: " + aFile);
    }
    if (!aFile.canWrite()) {
      throw new IllegalArgumentException("File cannot be written: " + aFile);
    }

    //use buffering
    Writer output = new BufferedWriter(new FileWriter(aFile));
    try {
      //FileWriter always assumes default encoding is OK!
      output.write( aContents );
    }
    finally {
      output.close();
    }
  }

  /** Simple test harness.   */
  public static void main (String... aArguments) throws IOException {
    File testFile = new File("C:\\Temp\\blah.txt");
    System.out.println("Original file contents: " + getContents(testFile));
    setContents(testFile, "The content of this file has been overwritten...");
    System.out.println("New file contents: " + getContents(testFile));
  }
}

Example 3
This example demonstrates using

Scanner to read a file containing lines of structured data. Each line is then parsed using a second Scanner and a simple delimiter character, used to separate each line into a name-value pair. The Scanner class is used only for reading, not for writing.

import java.io.*;
import java.util.Scanner;

public final class ReadWithScanner {

  public static void main(String... aArgs) throws FileNotFoundException {
    ReadWithScanner parser = new ReadWithScanner("C:\\Temp\\test.txt");
    parser.processLineByLine();
    log("Done.");
  }
  
  /**
  * @param aFileName full name of an existing, readable file.
  */
  public ReadWithScanner(String aFileName){
    fFile = new File(aFileName);  
  }
  
  /** Template method that calls {@link #processLine(String)}.  */
  public final void processLineByLine() throws FileNotFoundException {
    Scanner scanner = new Scanner(fFile);
    try {
      //first use a Scanner to get each line
      while ( scanner.hasNextLine() ){
        processLine( scanner.nextLine() );
      }
    }
    finally {
      //ensure the underlying stream is always closed
      scanner.close();
    }
  }
  
  /** 
  * Overridable method for processing lines in different ways.
  *  
  * <P>This simple default implementation expects simple name-value pairs, separated by an 
  * '=' sign. Examples of valid input : 
  * <tt>height = 167cm</tt>
  * <tt>mass =  65kg</tt>
  * <tt>disposition =  "grumpy"</tt>
  * <tt>this is the name = this is the value</tt>
  */
  protected void processLine(String aLine){
    //use a second Scanner to parse the content of each line 
    Scanner scanner = new Scanner(aLine);
    scanner.useDelimiter("=");
    if ( scanner.hasNext() ){
      String name = scanner.next();
      String value = scanner.next();
      log("Name is : " + quote(name.trim()) + ", and Value is : " + quote(value.trim()) );
    }
    else {
      log("Empty or invalid line. Unable to process.");
    }
    //(no need for finally here, since String is source)
    scanner.close();
  }
  
  // PRIVATE //
  private final File fFile;
  
  private static void log(Object aObject){
    System.out.println(String.valueOf(aObject));
  }
  
  private String quote(String aText){
    String QUOTE = "'";
    return QUOTE + aText + QUOTE;
  }
}

Example run of this class :

Name is : 'height', and Value is : '167cm'
Name is : 'mass', and Value is : '65kg'
Name is : 'disposition', and Value is : '"grumpy"'
Name is : 'this is the name', and Value is : 'this is the value'
Done.

java Framework/java]Http 통신

java :: http 통신

출처 : http://blog.naver.com/banhong/104373158

얼마전에 자바 어플리캐이션에서 http통신으로 데이터 값을 가져와야 하는것을 개발해야 해서

동작테스트 삼아 만들었쌈~..... 실제는 이렇게 안만들었지만 서도

/**
*
*/
package test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

/**
* @author 이준성
*
*/
public class HttpRequest {

private String url;

public HttpRequest(String url) {

  this.url = url;

}

public String request() {

  String returnVal = "";

  HttpURLConnection con = null;

  BufferedReader br = null;

  try {

   URL tempCon = new URL(url);
   con = (HttpURLConnection)tempCon.openConnection();

   // 메소드 방식설정
   con.setRequestMethod("POST");
   // 헤더 설정
   con.setRequestProperty("Content-Type" , "application/x-www-form-urlencoded");

   con.connect();

   InputStreamReader isr = new InputStreamReader(con.getInputStream());
   br = new BufferedReader(isr);

   String temp = null;

   while((temp = br.readLine()) != null) {

    System.out.println(temp);

   }

  }catch(IOException e) {

   e.printStackTrace();

  } finally {

   if(br != null) {
    try {
     br.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }

   con.disconnect();

  }

  return returnVal;
}

/**
* 동작 테스트
*
* @param args
*/
public static void main(String args[]) {

  //HttpRequest 생성시에 인자로 요청을 보낼 주소를 적으면 된다.
  //HttpRequest hr = new HttpRequest("");
  //hr.request();

}

}

자바에서 제공하는 HttpURLConnection 이란 녀석때문에 상당이 쉽게 만들수는 있다지만,
상당히 객체지향적이지 못하게 설계된 클래스라고 하네요. 흠~~ 구런가????

[출처] 자바로 (어플리캐이션) http통신하는 샘플소스 HttpURLConnection|작성자 달빛

서블릿과의 통신 가능한 클라이언트 작성에 대해서

출처 :

HTTP통신을 하는 서버와 클라이언트를 작성하려고 합니다. 서버측은 서블릿으로 작성을 하였습니다. 클라이언트단은 jsp나 html이 아닌 일반 어플리케이션을 이용해야 합니다. URLConnection클래스를 이용하여 서버에 접속하여 정보를 주고 받게끔 작성하였는데 클라이언트에서 정보를 보내는 것은 가능하나 서버로 부터 오는 정보를 다시 받는 방법을 모르겠습니다. 또한, jsp나 html는 form태크를 써서 서버에서 doPost함수에서 response할 수 있는반면 URLConnection으로 서버에 접속을 하게 되면 URL뒤에 정보가 붙어서 가는 Get방식으로 밖에 전송이 안되네요. 어떤 방법으로 클라이언트를 작성하는 것이 더 원활한 서블릿과의 통신방법이 될 수 있을까요? 아래에 소스를 첨부하겠습니다. 꼭 답변 부탁드릴께요.

<HttpClient>
import java.io.*;
import java.net.*;

import sun.net.www.protocol.http.HttpURLConnection;

public class HttpClient {

  public static void main(String[] args) {
    try {
    URL url = new URL("http://127.0.0.1:8080
                    /servlet/HttpTest?p=abc");
    HttpURLConnection huc = (HttpURLConnection)
                                   url.openConnection();

    huc.setDoOutput(true);
          OutputStream os = huc.getOutputStream();
    BufferedOutputStream bos = new BufferedOutputStream(os);
    BufferedInputStream bis = new BufferedInputStream
                                    (huc.getInputStream());
           //送信
    bos.write("abc".getBytes());
    bos.flush();
    System.out.println("end");

    //受信
    byte[] r = new byte[3];
    bis.read(r);
    System.out.println("read : "+new String(r));

    } catch (MalformedURLException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

<HttpServer>
import java.io.*;

import javax.servlet.*;
import javax.servlet.http.*;

public class HttpServer extends HttpServlet {

  public void service(HttpServletRequest request,
                         HttpServletResponse response)
    throws IOException {

     response.getOutputStream();
     BufferedInputStream bis = new BufferedInputStream
                               (request.getInputStream());
    byte[] r = new byte[3];
    System.out.println("start");
    int j = bis.read(r, 0, 3);
    System.out.println("read "+j+" : "+new String(r));
    //受信
    bis.read(r);
    System.out.println("read : "+new String(r));
    String str = request.getParameter("p");
    BufferedOutputStream bos = new BufferedOutputStream
                                     (response.getOutputStream());
    //送信
    bos.write(str.getBytes());
    bos.flush();
    System.out.println("write end ");
    }
}

2003-10-13 13:37:10.0 / 글번호 : 261780

::carroty:: 도움이 되실란가 모르겠지만...

dangguni

무슨 이유 때문인지 잘 모르겠지만, 아무튼 HTTP 통신을 하는 CS를 개발
하시는데, 클라이언트가 어플리케이션이어야 하는 이유를 잘 모르겠습니다. 다들 클라이언트를 웹브라우져안으로 이식하기위해 고생하는데 말이져.

클라이언트를 어플케이션으로 만드실것이라면, 애초에 걍 소켓 접속을
통해 프로그램을 만드시는 것이 어떤지요.
클라이언트는 걍 어플리케이션, 서버측도 걍 어플리케이션
이게 더 만들기도 편하고(편한가? *^^*) HTTP보다는 강력할 텐데요.

굳이 80 포트를 경유해야 한다면, 어플리케이션이 애플릿을 경유하여
작성하는 것도 괜찮은 방법이리라 생각됩니다.

클라이언트 프로그램 <-> 웹 브라우져 <-> (애플릿) <-- internet -->

웹 서버 <- 서블릿 -> core 서버 프로그램

머 이런식으로 하시는 것보다는 아래것이 더 낫지 않나요?

클라이언트 프로그램 <-- internet --> core 서버 프로그램

도움이 되시면 좋겠네염.

즐건 하루 되세염.

2003-10-13 14:32:08.0 / 글번호 : 261785

서블릿과 애플리케이션과의 통신의 예

javamaster

/**
  @explain : 서블릿테스트 클라이언트 by javamaster
*/
 
import java.io.*; 
import java.net.*;
import java.util.*;

import javax.servlet.*; 
import javax.servlet.http.*; 

public class HttpConnector{   
  DataInputStream dis;
  OutputStreamWriter writer; // 플래쉬 쓰기만
  String id; // 이 클라이언트가 서버로부터 할당받은 고유아이디  
  String host;
  public static void main(String[] args){ 
    HttpConnector con = new HttpConnector();
    con.initConnection("http://211.110.15.5/javamaster/servlet/Proxy2"); // 특정 URL로 서블릿 생성
  }

  /**
    @explain : 초기 접속 협상을 시도함
    @packet : 000    
  */
  public void initConnection(String _host){      
    host = _host;
    try{      
      URL url = new URL(_host);    
      URLConnection rconnector = url.openConnection();        
      rconnector.setDoOutput(true);
      
      Writer flashwriter = new OutputStreamWriter(rconnector.getOutputStream(), "euc-kr");   
      flashwriter.write("000\n");
      flashwriter.flush();
      flashwriter.close();

      dis = new DataInputStream(rconnector.getInputStream());
      // 이부분에서 무한으로 read() 상태에 있게 된다. 서버와의 통신부분의 핵심
      String line="";
      
      while((line = dis.readLine()) != null){
        System.out.println("서블릿으로 부터 : " + line);      
        if(line.indexOf("000") == 0){ // 초기접속 ok이므로, 서버로 부터 고유아이디를 받았다면 writer를 생성해야 함
          id = line.substring(line.indexOf(" ") + 1, line.length());
          //writeToServer("001 " + id);          
        }else if(line.indexOf("001") == 0){
          System.out.println("history : writer생성 협상 성공,, 이후 서버스 진행하면 됨");  
        }else{
          // 이곳에서 클라이언트 프로토콜을 위임함
          System.out.println("서버로 부터 : " + line);  
        }
        System.out.println("서버로부터 데이터가 오기를 대기함");
      }      
      System.out.println("모든 것 종료");
      
    }catch(Exception e){
      e.printStackTrace();  
    }finally{
    
    }      
  } 
  /**
    @explain : 연결된 writer 객체를 이용해서 서버로 전송
  */
  public void writeToServer(String _packet){
    try{
      URL url = new URL(host);    
      URLConnection wconnector = url.openConnection();        
      wconnector.setDoOutput(true);
      
      // 현재의 writer를 멤버writer로 등록
      OutputStreamWriter writer = new OutputStreamWriter(wconnector.getOutputStream(), "euc-kr");        
      writer.write(_packet + "\n");
      writer.flush();
      writer.close();
      System.out.println("서블릿에 전송 : " + _packet);
      // 응답을 받기위해 임의로
      BufferedReader reader2 = new BufferedReader(new InputStreamReader(wconnector.getInputStream(),"latin1"));      
      reader2.close();
    }catch(Exception e){
      e.printStackTrace();  
    }
  }
}
                    
위의 소스는 일본 KDDI 무선네트워크 프로젝트를 하면서 작성한 것입니다
서버 - 서블릿 - 무선핸드폰 이 실제 구조이고
서버 - 서블릿 - 애플리케이션 의 구조로 실제 서비스전에 데이터 통신에
대한 무선핸드폰 부분을 가상 테스트 하게 됩니다.
혹시 일본쪽 프로젝트신가요?

테스트를 해보시고 궁금하신거나 다른 부분에 대한 문의가 있으시면
제 홈페이지에 방문해 보시기 바랍니다.
요즘 문서 정리중이라 서블릿 부분이 추가 되어서.
그럼

javamaster wild world

제RssReader_Http통신예.zip

아파치 HttpClient 3.x 기준 설명 ..1-1. HttpClient 소개
HttpClient은 HTTP상에서 커뮤니케이션을 하는 자바 기반의 어플리케이션 개발을 쉽게 할수 있도록 제공한다.
우리가 웹 브라우저 또는 그에 준하는 어플리케이션을 개발한다면 HttpClient은 우리에게 클라이언트 코드 개발에 도움을 줄수있다.
이름에서 의미하는것과 같이 HttpClient는 오직 HTTP 클라이언트 코드을 위한 컴포넌트이지 HTTP 요청을 처리하는 서버측 프로세스을 지원하지는 않는다.
1-2. 설치
현재 아파치 HttpClient 는 3.0.1 안정버전을 지원한다.
Jakarta Commons HttpClient 페이지에서 다운로드 받으면 된다.
(다운로드 페이지: http://jakarta.apache.org/commons/httpclient/downloads.html)
(최신버전 다운로드:
- http://jakarta.apache.org/site/downloads/downloads_commons-httpclient.cgi
- http://mirror.apache-kr.org/jakarta/commons/httpclient/binary/commons-httpclient-3.0.1.zip
)
commons-httpclient-3.0.1.zip 를 받아서 압축을 풀고,
commons-httpclient-3.0.1.jar 를 CLASSPATH 에 추가하면 된다.
1-3. 추가 설정(Dependencies)
http://jakarta.apache.org/commons/httpclient/dependencies.html

Artifact ID Type Version Scope URL Comment
commons-codec jar 1.2  http://jakarta.apache.org/commons/codec/
   http://jakarta.apache.org/site/downloads/downloads_commons-codec.cgi
commons-logging jar 1.0.4  http://jakarta.apache.org/commons/logging/
junit jar 3.8.1 test  http://www.junit.org/

[JAVA] httpClient 샘플 ============================
출처 ; http://www.albumbang.com/board/board_view.jsp?board_name=free&no=126

package test;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.MultipartPostMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.util.EncodingUtil;

public class HttpClientHelper {
    public HttpClientHelper(String urlStr){
        this.urlStr = urlStr;
        paramList = new ArrayList();
    }

    private String urlStr = "";
    private String content = "";
    private int methodType = 0;
    private int iGetResultCode = 0;
    private int connectionMaxTime = 5000;

    private static final int GETTYPE = 0;
    private static final int POSTTYPE = 1;
    private static final int MULTIPARTTYPE = 2;

    public String getContent() {
        return content;
    }

    public int getIGetResultCode() {
        return iGetResultCode;
    }

    private List paramList = null;

    public void setParam(String key, String value) {
        paramList.add(new NameValuePair(key,value));
    }

    public int getMethodType() {
        return methodType;
    }

    public void setMethodType(int methodType) {
        this.methodType = methodType;
    }

    public int execute() {
        iGetResultCode = 0;
        HttpClient client = null;
        HttpMethod method = null;
        NameValuePair[] paramArray = new NameValuePair[paramList.size()];
        paramList.toArray(paramArray);
        try {
            client = new HttpClient(new MultiThreadedHttpConnectionManager());
            client.setTimeout(getConnectionMaxTime());

            if(methodType == GETTYPE){
                GetMethod getMethod = new GetMethod(urlStr);
                if(paramArray.length > 0)
                    getMethod.setQueryString(EncodingUtil.formUrlEncode(paramArray,"euc-kr"));
                method = getMethod;
            }else if(methodType == POSTTYPE){
                PostMethod postMethod = new PostMethod(urlStr);
                for(int k = 0; k < paramArray.length; k++){
                    postMethod.addParameter(paramArray[k].getName(), new String(paramArray[k].getValue().getBytes(),"ISO-8859-1"));
                }
                method = postMethod;
            }else if(methodType == MULTIPARTTYPE){
                MultipartPostMethod multipartPostMethod = new MultipartPostMethod(urlStr);
                for(int k = 0; k < paramArray.length; k++){
                    multipartPostMethod.addParameter(paramArray[k].getName(), paramArray[k].getValue());
                }
                method = multipartPostMethod;
            }
            // method.setFollowRedirects(true);

            iGetResultCode = client.executeMethod(method);
            if(iGetResultCode == HttpStatus.SC_OK)
            {
                content = method.getResponseBodyAsString();
            }
        } catch (Exception e) {
            iGetResultCode = 0;
        }finally{
            if(method != null) method.releaseConnection();
        }
        return iGetResultCode;
    }

    public int getConnectionMaxTime() {
        return connectionMaxTime;
    }

    public void setConnectionMaxTime(int connectionMaxTime) {
        this.connectionMaxTime = connectionMaxTime;
    }
}

--------------------------------------------------------------------------------

package test;

import gshs.eshop.common.httputil.HttpClientHelper;

public class TestSimple {
    private void testPostMethod() {
        System.out.println("testPostMethod() start ###################################");

        String urlStr = "http://kkaok.pe.kr/frameset/door.jsp";
        HttpClientHelper test = new HttpClientHelper(urlStr);
        // 넘겨줄 파라미터 세팅
        test.setParam("act", "/servlet/KBoard?tableName=kjsp");
        // setMethodType을 지정하지 않으면 default = 0, (0:get, 1:post, 2:multipart)
        test.setMethodType(1);
        // connection 연결시간 설정 default = 5000;
        test.setConnectionMaxTime(5000);

        int rtnCode = test.execute(); // 실행하기
        System.out.println(rtnCode); // 결과 값. 200이면 정상
        System.out.println(test.getIGetResultCode()); // rtnCode 값을 결과 값이다.
        System.out.println(test.getContent()); // 해당 페이지의 내용 불러오기
    }

    private void testGetMethod() {
        System.out.println("testGetMethod() start ###################################");
        String urlStr = "http://kkaok.pe.kr/frameset/door.jsp";
        HttpClientHelper test = new HttpClientHelper(urlStr);
        test.setParam("act", "/servlet/KBoard?tableName=kjsp");
        // setMethodType을 지정하지 않으면 default = 0, (0:get, 1:post, 2:multipart)
        test.setMethodType(0);
        // connection 연결시간 설정 default = 5000;
        test.setConnectionMaxTime(5000);

        int rtnCode = test.execute();
        System.out.println(rtnCode); // 결과 값. 200이면 정상
        System.out.println(test.getIGetResultCode()); // rtnCode 값을 결과 값이다.
        System.out.println(test.getContent()); // 해당 페이지의 내용 불러오기
    }

    private void testGetMethodSample() {
        System.out.println("testGetMethodSample() start ###################################");
        String urlStr = "http://kkaok.pe.kr/frameset/door.jsp";
        HttpClientHelper test = new HttpClientHelper(urlStr);
        test.setParam("act", "/servlet/KBoard?tableName=kjsp");
        // setMethodType을 지정하지 않으면 default = 0, (0:get, 1:post, 2:multipart)
        test.setMethodType(0);
        // connection 연결시간 설정 default = 5000;
        test.setConnectionMaxTime(5000);

        int count = 5;
        int rtnCode = 0;
        for (int i = 0; i < count; i++) {
            System.out.println("count : " + (i + 1));
            rtnCode = test.execute();
            if (rtnCode == 200) {
                break;
            }
        }
        if (rtnCode == 200) {
            System.out.println(test.getIGetResultCode());
            System.out.println(test.getContent());
        }
    }

    private void testNoMethodOnlyUrl() {
        System.out.println("testNoMethodOnlyUrl() start ###################################");
        String urlStr = "http://kkaok.pe.kr/frameset/door.jsp?act=/servlet/KBoard?tableName=kjsp";
        HttpClientHelper test = new HttpClientHelper(urlStr);
        int rtnCode = test.execute();
        System.out.println(rtnCode); // 결과 값. 200이면 정상
        System.out.println(test.getIGetResultCode()); // rtnCode 값을 결과 값이다.
        System.out.println(test.getContent()); // 해당 페이지의 내용 불러오기

    }

    public static void main(String[] args) {
        TestSimple test = new TestSimple();
        test.testGetMethod();
        test.testPostMethod();
        test.testNoMethodOnlyUrl();
        test.testGetMethodSample();
    }
}

HttpClient 4.x버전으로 올라오면서 조쿰 바뀐 것 같습니다.
기록용으로 기록합니다-_-
아래 예제는.....티월드사이트의 무료사용량 조회 예제입니다-_-

출처 : http://mudchobo.tomeii.com/tt/479

Java] HttpClient 4.x 버전 예제

import java.net.URI;import java.util.ArrayList;import java.util.List;
import org.apache.http.Header;import org.apache.http.HttpResponse;import org.apache.http.NameValuePair;import org.apache.http.client.HttpClient;import org.apache.http.client.ResponseHandler;import org.apache.http.client.entity.UrlEncodedFormEntity;import org.apache.http.client.methods.HttpGet;import org.apache.http.client.methods.HttpPost;import org.apache.http.impl.client.BasicResponseHandler;import org.apache.http.impl.client.DefaultHttpClient;import org.apache.http.message.BasicNameValuePair;
publicclassMain{
/**

     * @param args

     */publicstaticvoid main(String[] args)throwsException{HttpClient httpclient =newDefaultHttpClient();

        String id ="t월드 아이디";String pw ="비밀번호";

        List<NameValuePair> qparams =newArrayList<NameValuePair>();

        qparams.add(newBasicNameValuePair("URL","http://www.tworld.co.kr/loginservlet.do?returnURL=http%3A%2F%2Fwww.tworld.co.kr&kind=&popup=&cmd=&reload=&ID="+ id));

        qparams.add(newBasicNameValuePair("ID", id));

        qparams.add(newBasicNameValuePair("PASSWORD", pw));

        qparams.add(newBasicNameValuePair("SERVERIP","203.236.20.129"));

        qparams.add(newBasicNameValuePair("X","0"));

        qparams.add(newBasicNameValuePair("Y","0"));UrlEncodedFormEntity entity =newUrlEncodedFormEntity(qparams,"UTF-8");HttpPost httpPost =newHttpPost("http://nicasams.sktelecom.com:2040/icas/fc/LogOnSV");

        httpPost.setEntity(entity);

        ResponseHandler<String> responseHandler =newBasicResponseHandler();String responseBody ="";HttpResponse response = httpclient.execute(httpPost);Header[] headers  = response.getAllHeaders();

        httpclient =newDefaultHttpClient();HttpGet httpGet =newHttpGet();if(headers.length >1){String url = headers[1].getValue();System.out.println("url = "+ url);

            httpGet.setURI(new URI(url));

            responseBody = httpclient.execute(httpGet, responseHandler);System.out.println(responseBody);}

        httpGet.setURI(new URI("http://www.tworld.co.kr/normal.do?serviceId=S_BILL0070&viewId=V_CENT0261"));

        responseBody = httpclient.execute(httpGet, responseHandler);

        System.out.println("result = "+ responseBody);}}

java Framework/java]Bean to XML

package org.kodejava.example.bean;

import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

public class BeanToXML {
    private Long id;
    private String itemName;
    private String itemColour;
    private Integer itemQuantities;

    public static void main(String[] args) {
        BeanToXML bean = new BeanToXML();
        bean.setId(new Long(1));
        bean.setItemName("T-Shirt");
        bean.setItemColour("Dark Red");
        bean.setItemQuantities(new Integer(100));

        try {
            XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(
                    new FileOutputStream("Bean.xml")));

            //
            // Write an XML representation of the specified object to the output.
            //
            encoder.writeObject(bean);
            encoder.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getItemName() {
        return itemName;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    public String getItemColour() {
        return itemColour;
    }

    public void setItemColour(String itemColour) {
        this.itemColour = itemColour;
    }

    public Integer getItemQuantities() {
        return itemQuantities;
    }

    public void setItemQuantities(Integer itemQuantities) {
        this.itemQuantities = itemQuantities;
    }
}

The XML persistence will be like:

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

<java version="1.6.0_02" class="java.beans.XMLDecoder"> 

 <object class="org.kodejava.example.bean.BeanToXML"> 

  <void property="id"> 

   <long>1</long> 

  </void> 

  <void property="itemColour"> 

   <string>Dark Red</string> 

  </void> 

  <void property="itemName"> 

   <string>T-Shirt</string> 

  </void> 

  <void property="itemQuantities"> 

   <int>100</int> 

  </void> 

 </object> 

</java>

java Framework/java] 파일 이어받기 기능 구현

출처 :http://webprogrammer.tistory.com/tag/%EC%9E%90%EB%B0%94%EC%97%90%EC%84%9C%20%ED%8C%8C%EC%9D%BC%20%EC%9D%B4%EC%96%B4%EB%B0%9B%EA%B8%B0%20%EA%B8%B0%EB%8A%A5

자바에서 파일 쓰기 할 때
BufferedWriter file = new BufferedWriter(new FileWriter("filename"));
대개의 경우 이런식으로 코딩을 했었는데, 이 코드는 파일을 덮어쓴다.
파일을 덮어쓰지 않고 이어쓰기하는 방법이 없을까 하고 고민하고 찾아봤다.
RandomAccessFile 클래스를 사용하는 방법도 있었고
그리고 파일을 쭉 읽어서 변수에 저장을 한 뒤 새로 추가할 내용을 덧붙여서 파일에 쓰는 방법도 있었다.
하지만 뭔가 더 간편한게 있을 것 같아서 찾아봤더니
이 한문장이면 파일 이어쓰기가 가능하다.

BufferedWriter file = new BufferedWriter(new FileWriter("filename", true));

이 코드는 파일이 없으면 새로 만들고 있다면 덮어쓰지 않고 이어서 쓰게한다.

그리고 파일에서 개행문자를 쓰려고할 때
C나 C++에서처럼 당연히 ""이 먹힐거라 생각을 하고
str = str + "";
file.write(str, 0, str.length());
이렇게 썼는데 파일에는 줄바꿈이 되어있지 않았다.
알아본 결과 저 위에서 사용한 FileWriter가 가독성때문에 ""을 지원하지 않기 때문이었다.
BufferedWriter를 통해서 개행문자를 쓸 수 있다.
바로 이렇게..

file.write(str, 0, str.length());
file.newLine();

간단하다. 하하하;;;
이 사실을 난... 어제 알았다. 쿨럭 -_-;;;
까먹을까봐...

-------------------------------

기존파일에 덧붙여서 내용을 저장하려면, RandomAccessFile 클래스를 사용해야 합니다.
아래는 간단한 예제 입니다.

출처 : http://finetia.egloos.com/1422965
—————————————————————————
import java.io.IOException;
import java.io.RandomAccessFile;
public class UsingFile {
public UsingFile() {
}
public static void main(String[] args) {
try {
String name = “c:\\tmpfile.txt”;
RandomAccessFile raf = new RandomAccessFile(name, “rw”);
raf.seek(raf.length());
raf.writeBytes(“\r\n append”);
}
catch (IOException e) {
System.out.println(“Error opening file: ” + e);
}
}
}

출처 : http://rothmans.wordpress.com/2006/07/12/%EC%86%8C%EC%8A%A4%ED%8C%8C%EC%9D%BC-%EC%9D%B4%EC%96%B4-%EC%93%B0%EA%B8%B0/

java] SimpleDateFormate 예제

출처 : http://www.ssial.com/141

import java.text.SimpleDateFormat;

.
.
.

Format formatter;

// The year
formatter = new SimpleDateFormat("yy");    // 02
formatter = new SimpleDateFormat("yyyy"); // 2002

// The month
formatter = new SimpleDateFormat("M"); // 1
formatter = new SimpleDateFormat("MM");    // 01
formatter = new SimpleDateFormat("MMM"); // Jan
formatter = new SimpleDateFormat("MMMM"); // January

// The day
formatter = new SimpleDateFormat("d"); // 9
formatter = new SimpleDateFormat("dd");    // 09

// The day in week
formatter = new SimpleDateFormat("E"); // Wed
formatter = new SimpleDateFormat("EEEE"); // Wednesday

// Get today's date
Date date = new Date();

// Some examples
formatter = new SimpleDateFormat("MM/dd/yy");
String s = formatter.format(date);
// 01/09/02

formatter = new SimpleDateFormat("dd-MMM-yy");
s = formatter.format(date);
// 29-Jan-02

// Examples with date and time; see also
// e316 Formatting the Time Using a Custom Format
formatter = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss");
s = formatter.format(date);
// 2002.01.29.08.36.33

formatter = new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss Z");
s = formatter.format(date);
// Tue, 09 Jan 2002 22:14:02 -0500

// The hour (1-12)
formatter = new SimpleDateFormat("h"); // 8
formatter = new SimpleDateFormat("hh");    // 08

// The hour (0-23)
formatter = new SimpleDateFormat("H"); // 8
formatter = new SimpleDateFormat("HH");    // 08

// The minutes
formatter = new SimpleDateFormat("m"); // 7
formatter = new SimpleDateFormat("mm");    // 07

// The seconds
formatter = new SimpleDateFormat("s"); // 3
formatter = new SimpleDateFormat("ss");    // 03

// The am/pm marker
formatter = new SimpleDateFormat("a"); // AM

// The time zone
formatter = new SimpleDateFormat("z"); // PST
formatter = new SimpleDateFormat("zzzz"); // Pacific Standard Time
formatter = new SimpleDateFormat("Z"); // -0800

// Get today's date
Date date = new Date();

// Some examples
formatter = new SimpleDateFormat("hh:mm:ss a");
String s = formatter.format(date);
// 01:12:53 AM

formatter = new SimpleDateFormat("HH.mm.ss");
s = formatter.format(date);
// 14.36.33

출처: http://www.exampledepot.com/egs/java.text/pkg.html#Times

JAVA] RSS Reader 만들기

** java]Http 통신 의 예제 파일 참조

javascript를 이용한 초간단 Rss Reader 구현하기 : javascript 를 이용한 초간단 Rss Reader 구현하기
참조사이트 : http://blog.naver.com/sullim75?Redirect=Log&logNo=140028752352

춣처 : http://poolpiri.egloos.com/7021118

간단한 Rss Reader 만들기...

블로그를 만들어보다가 Rss를 읽어서 웹상에서 보여주는 RssReader가 필요할꺼 같아서...

간단하게 만들어봅니다.

자카르타 오픈 컴포넌트중에 하나인 commons.digester를 이용한겁니다...그래서 간단허져...

일단 아래와 같이 간단한 메서드를 만들어봅니다.

/**
* RSSDigester를 이용해서 링크의 스트림(xml)을 파싱해서 Channel객체를 리턴한다.
*
* @param xmlLink
* @param response
* @return org.apache.commons.digester.rss.Channel
* @throws Exception
*/

private Channel getChannel(String xmlLink)
      throws Exception {
    Channel chan = null;
    try {
       RSSDigester digester = new RSSDigester();
      // 방법 1. Rss Link를 이용한 파싱...
       //chan = (Channel) digester.parse(xmlLink);
       // 방법 2. Rss Link를 URL로 연결해서 얻은 스트림으로 파싱...
       //chan = (Channel) digester.parse(new URL(xmlLink).openStream());
       // 방법 3. 국내 사이트 Character Encoding문제 때문에...추가...
       chan = (Channel) digester.parse(getEncodedReader(xmlLink));
    } catch (java.io.IOException ioe) {
       chan = new Channel();
       chan.setTitle("ERROR");
       StringBuffer sb = new StringBuffer("<span class="error">");
       sb.append("IOException parsing RSS XML LINK : " + xmlLink);
       sb.append("</span>n<p>");
       sb.append(ioe.toString());
       chan.setDescription(sb.toString());
    } catch (org.xml.sax.SAXException se) {
       chan = new Channel();
       chan.setTitle("ERROR");
       StringBuffer sb = new StringBuffer("<span class="error">");
       sb.append("SAXException parsing RSS XML LINK : " + xmlLink);
       sb.append("</span>n<p>");
       sb.append(se.toString());
       chan.setDescription(sb.toString());
    }
return chan;
}

파라미터로 와야하는 String xmlLink은 본 엠파스 블로그에 있는거같은 RSS링크 유알엘을 넣어주심 됩니다. 제 블로그를 예를 들면..."http://blog.empas.com/poolpiri3/rss.xml" 이게 들어오면 되는겁니다.
여기 예제는 엠파스에서 제공하는 rss.2.0 버전에만 잘돌아갑니당...이 버전은 웬만한 국내 RSS가 지원하는 버전입니다...

소스 중간에 있는 주석을 보시면 몇가지 방법이 있습니다만...국내 사이트의 경우 한글 인코딩 문제로 파싱이 제대로 안됩니다. 여기 엠파스도 마찬가지구여... 이럴줄 알았으면 굳이 digester를 쓰지 않고 방법을 생각했으면 더 쉬워질 수 도 있었습니다만...제가 무지한지라...하여 아래와 같은 메서드를 무식하게 추가했습니다.

/**
* xml파일의 encoding타입을 읽어서 그 타입대로 컨버전후 InputStreamReader를 리턴한다.
*
* @param xmlLink
* @return InputStreamReader
*/

private InputStreamReader getEncodedReader(String xmlLink) {
   URL url = null;
    InputStreamReader reader = null;
    BufferedReader br = null;
    try {
       url = new URL(xmlLink);
       reader = new InputStreamReader(url.openStream());
       byte b[] = new byte[1024];
       br = new BufferedReader(reader);
       String line = br.readLine();
       while (line != null) {
          if (!(line.trim().equals(""))) {
             int index = line.toLowerCase().indexOf("encoding");
             String prefix = """;
             String encoding = "";
             if (index != -1) {
                int start = line.indexOf(prefix, index) + 1;
                if (start == -1) {
                   prefix = "'";
                   start = line.indexOf(prefix, index) + 1;
                   if (start == -1) {
                     start = line.indexOf("=", index) + 1;
                     prefix = "?";
                   }
                }
             encoding = line.substring(start, line.indexOf(prefix, start));
             if (encoding != null && !("".equals(encoding))) {
                reader = new InputStreamReader( url.openStream(), encoding.trim());
             } else {
                reader = new InputStreamReader(url.openStream());
             }
       } else {
          reader = new InputStreamReader(url.openStream());
       }
    break;
   }
   line = br.readLine();
   }
   } catch (MalformedURLException e) {
       e.printStackTrace();
    } catch (IOException e) {
       e.printStackTrace();
    } finally {
       if (br != null) {
          try {
             br.close();
          } catch (IOException e1) {
             e1.printStackTrace();
          }
       }
    }
    return reader;
}

하여튼 이렇게 얻어진 channel를 객체를 통해서 아래와 같이 jsp에서 뿌려주심 됩니다.

<% int maxItems = 10;
if (channel != null) {
if ("ERROR".equals(channel.getTitle())) {%>
<tr bgcolor="#FFCCFF">
<td width="100" bgcolor="#CCCCFF">블로그 이름</td>
<td bgcolor="#CCFFCC"><%=channel.getDescription()%></td>
</tr>
<%return;
}%><% String divId = Utility.replace(channel.getTitle(), " ", "_");
divId = Utility.replace(channel.getTitle(), "'", "_");%>

<tr bgcolor="#FFCCFF">
<td bgcolor="#CCFFCC" width="500" colspan="2" valign="bottom"><a href="<%=channel.getLink()%>" target="_blank"><h3><%=channel.getTitle()%></h3></a><br>
<%=channel.getDescription()%></td>
</tr>
<% Image image = channel.getImage();
if (image != null) {%><tr bgcolor="#FFFFFF">
<td colspan="2" height="50"><img src="<%=image.getURL()%>" alt="<%=image.getTitle()%>" > 
</td>
</tr>
<% }
Item[] items = channel.getItems();
for (int j = 0; j < items.length; j++) {if (items[j].getTitle() != null && items[j].getLink() != null) {%>
<tr bgcolor="#FFFFFF">
<td colspan="2"><a href="<%=items[j].getLink()%>" target="_blank" class="RssLink"><%=items[j].getTitle()%></a></td>
</tr>
<% } else if (items[j].getTitle() != null) {%><tr bgcolor="#FFFFFF">
<td colspan="2"><div class="RssTitle"><%=items[j].getTitle()%></div></td>
</tr>
<% }
if (items[j].getDescription() != null) {%><tr bgcolor="#FFFFFF">
<td colspan="2"><div class="RssDesc"><%=items[j].getDescription()%>...</div></td>
</tr>
<% }
if (maxItems != -1 && j >= maxItems)
break;
}
} else {%>
<tr bgcolor="#FFFFFF">
<td colspan="2">블로그 리스트가 하나도 없습니다. -_-</td>
</tr>
<% }%>

흠흠...제가 봐도 어설프네여...

이렇게 하면 자기 홈페이지나 특정사이트에 기존에 IFRAME같은 방법으로 넣어줬던 다른 사이트의 특정 게시물 리스트를 RSS와 RSS Reader를 통해서 출력해줄 수 있습니다.

물론 항상 신규 리스트겠죠 또한 해당 사이트에서 RSS를 지원해야만 가능한거구여...요샌 상당수 사이트들이 지원을 하구여...

그럼...

위의 소스는 commons.digester 1.5/1.6 을 기준으로 작성 되어서 2.x에서는 RSSDigester()를 찾을 수 없었다...(2010.07.06 기준)
그래서 아래의 소스로 rss reader를 구현하게 되었다...

RssReader.java
=================================

package rss;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.Scanner;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.CharacterData;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class RssReader {

    private static RssReader instance = null;
    private static String ENCODING = "UTF-8";
    static String NL = System.getProperty("line.separator");

    private RssReader() {
    }

    public static RssReader getInstance() {
        if(instance == null) {
            instance = new RssReader();
        }
        return instance;
    }

    public void writeNews() {
        try {

            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
//            URL u = new URL("http://mutasyon.net/cs/blogs/hakkiocal/rss.aspx");
//            URL u = new URL("http://rss.joins.com/joins_news_list.xml");
//            URL u = new URL("http://feeds.feedburner.com/afriken");
            URL u = new URL("http://blog.rss.naver.com/jeffyang.xml");

            Document doc = builder.parse(u.openStream());

            NodeList nodes = doc.getElementsByTagName("item");
            NodeList nodeChannel = doc.getElementsByTagName("channel");

            for(int i=0;i<nodes.getLength();i++) {

                Element element = (Element)nodes.item(i);

                System.out.println("Title: " + getElementValue(element,"title"));
                System.out.println("Category: " + getElementValue(element,"category"));
                System.out.println("Link: " + getElementValue(element,"link"));
                System.out.println("Publish Date: " + getElementValue(element,"pubDate"));
                System.out.println("author: " + getElementValue(element,"author"));
                System.out.println("comment: " + getElementValue(element,"comments"));
                System.out.println("guid: " + getElementValue(element,"guid"));
                System.out.println("language: " + getElementValue(element,"language"));
                System.out.println("description: " + getElementValue(element,"description"));
                System.out.println();
            }//for
        }//try
        catch(Exception ex) {
        ex.printStackTrace();
        }

    }

    public void writeNews(String url) {
        try {

            DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();

            URL u = new URL(url);

            Document doc = builder.parse(u.openStream());

            NodeList nodes = doc.getElementsByTagName("item");

            for(int i=0;i<nodes.getLength();i++) {

                Element element = (Element)nodes.item(i);

                System.out.println("Title: " + getElementValue(element,"title"));
                System.out.println("Category: " + getElementValue(element,"category"));
                System.out.println("Link: " + getElementValue(element,"link"));
                System.out.println("Publish Date: " + getElementValue(element,"pubDate"));
                System.out.println("author: " + getElementValue(element,"author"));
                System.out.println("comment: " + getElementValue(element,"comments"));
                System.out.println("guid: " + getElementValue(element,"guid"));
                System.out.println("language: " + getElementValue(element,"language"));
                System.out.println("description: " + getElementValue(element,"description"));
                System.out.println();
            }//for
        }//try
        catch(Exception ex) {
            ex.printStackTrace();
        }

    }


    private String getCharacterDataFromElement(Element e) {
        try {
            Node child = e.getFirstChild();
            if(child instanceof CharacterData) {
                CharacterData cd = (CharacterData) child;
                return cd.getData();
            }
        }
        catch(Exception ex) {

        }
        return "";
    } //private String getCharacterDataFromElement

    protected float getFloat(String value) {
        if(value != null && !value.equals("")) {
            return Float.parseFloat(value);
        }
        return 0;
    }

    protected String getElementValue(Element parent,String label) {
        return getCharacterDataFromElement((Element)parent.getElementsByTagName(label).item(0));
    }

    /**
    * 파일 읽기
    * @param ctx
    * @param fileName
    * @return
    * @throws FileNotFoundException
    */
    public static StringBuffer readFile(String fileName, String fEncoding) throws FileNotFoundException {
        StringBuffer result = new StringBuffer();
//        Scanner scanner = new Scanner(new File(fileName), fEncoding);
        try {
            BufferedReader in = new BufferedReader(new FileReader(fileName));
            try {
                String line = null;

                while ((line=in.readLine()) != null) {
                    result.append(line+NL);
                }
            } finally {
                in.close();
            }
//            while (scanner.hasNextLine()) {
//                result.append(scanner.nextLine()+NL);
//            }
        }catch(IOException ex ) {
            ex.printStackTrace();
        }

        return result;
    }

    public static StringBuffer readFileScanner(String fileName, String fEncoding) throws FileNotFoundException {
        StringBuffer result = new StringBuffer();
        Scanner scanner = new Scanner(new File(fileName), fEncoding);
        try {
            while (scanner.hasNextLine()) {
                result.append(scanner.nextLine()+NL);
            }
        } finally {
                scanner.close();
        }

        return result;
    }

    public static void main(String[] args) {
        try {
//            StringBuffer strUrl = readFile(args[0], ENCODING);
            StringBuffer strUrl = readFileScanner(args[0], ENCODING);
            if(strUrl != null ){
                String[] urls = strUrl.toString().split(NL);
                for(int i=0; i < urls.length;i++) {
                    RssReader reader = RssReader.getInstance();
                    reader.writeNews(urls[i]);
                }
            }

            RssReader reader = RssReader.getInstance();
            reader.writeNews();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
//            e.printStackTrace();
            System.out.println("지정된 파일을 찾을 수 없습니다. 파일을 확인하시기 바랍니다.");
        }

    }
}