유용한 Eclipse Java 코드 템플릿 찾기 [닫기]

Eclipse를 통해 다양한 Java 코드 템플릿을 만들 수 있습니다.

창> 환경 설정> Java> 편집기> 템플리트

예 :

sysout 다음으로 확장됩니다.

System.out.println(${word_selection}${});${cursor}

당신은 입력하여이를 활성화 할 수 있습니다 sysout다음CTRL+SPACE

현재 어떤 유용한 Java 코드 템플릿을 사용하고 있습니까? 그것의 이름과 설명을 포함하고 왜 멋진 지.

내장 기능이 아닌 템플릿의 독창적이거나 새로운 사용을 찾고 있습니다.

• Log4J 로거 작성
• 디스플레이에서 swt 색상 얻기
• Syncexec-Eclipse 프레임 워크
• 싱글 톤 패턴 / Enum 싱글 톤 생성
• 읽기 파일
• 콘 스트
• 쫓다
• 형식 문자열
• 주석 코드 검토
• 문자열 형식
• 마지막으로 잠금 시도
• 메시지 형식 i18n 및 로그
• 이퀄라이저
• 해시 코드 빌더
• 스프링 객체 주입
• FileOutputStream 작성

다음 코드 템플릿은 로거를 생성하고 필요한 경우 올바른 가져 오기를 생성합니다.

SLF4J

${:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOG = LoggerFactory.getLogger(${enclosing_type}.class);

Log4J 2

${:import(org.apache.logging.log4j.LogManager,org.apache.logging.log4j.Logger)} 
private static final Logger LOG = LogManager.getLogger(${enclosing_type}.class); 

Log4J

${:import(org.apache.log4j.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class);

소스 .

7 월

${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());

여기에 몇 가지 추가 템플릿 : Link I - Link II

난이게 좋아:

readfile

 ${:import(java.io.BufferedReader,  
           java.io.FileNotFoundException,  
           java.io.FileReader,  
           java.io.IOException)}  
 BufferedReader in = null;  
 try {  
    in = new BufferedReader(new FileReader(${fileName}));  
    String line;  
    while ((line = in.readLine()) != null) {  
       ${process}  
    }  
 }  
 catch (FileNotFoundException e) {  
    logger.error(e) ;  
 }  
 catch (IOException e) {  
    logger.error(e) ;  
 } finally {  
    if(in != null) in.close();  
 }  
 ${cursor} 

업데이트 :이 템플릿의 Java 7 버전은 다음과 같습니다.

${:import(java.nio.file.Files,
          java.nio.file.Paths,
          java.nio.charset.Charset,
          java.io.IOException,
          java.io.BufferedReader)}
try (BufferedReader in = Files.newBufferedReader(Paths.get(${fileName:var(String)}),
                                                 Charset.forName("UTF-8"))) {
    String line = null;
    while ((line = in.readLine()) != null) {
        ${cursor}
    }
} catch (IOException e) {
    // ${todo}: handle exception
}

문자열 형식

MessageFormat-선택 사항을 MessageFormat으로 둘러 쌉니다.

 ${:import(java.text.MessageFormat)} 
 MessageFormat.format(${word_selection}, ${cursor})

이를 통해 커서를 문자열로 이동하고 선택을 전체 문자열 (Shift-Alt-Up)로 확장 한 다음 Ctrl-Space를 두 번 확장 할 수 있습니다.

선택 잠금

잠그기-마지막으로 잠그기를 시도하여 선택한 줄을 둘러싸십시오. 잠금 변수가 있다고 가정하십시오.

${lock}.acquire();
try {
    ${line_selection}
    ${cursor}
} finally {
    ${lock}.release();
}

NB ${line_selection}템플릿은 Surround With 메뉴 (Alt-Shift-Z)에 나타납니다.

나는 죽은 게시물을 차고 있지만 완료를 위해 이것을 공유하고 싶었습니다.

결함이있는 이중 검사 잠금 설계를 극복하는 올바른 버전의 싱글 톤 생성 템플릿 (위에서 논의하고 다른 곳에서 언급)

싱글 톤 생성 템플릿 : 이름 지정createsingleton

static enum Singleton {
    INSTANCE;

    private static final ${enclosing_type} singleton = new ${enclosing_type}();

    public ${enclosing_type} getSingleton() {
        return singleton;
    }
}
${cursor}

위를 사용하여 생성 된 싱글 톤에 액세스하려면 :

싱글 톤 참조 템플릿 : 이름을 다음 getsingleton과 같이 지정합니다 .

${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();

반복하는 코드 스 니펫 추가 Map.entrySet():

주형:

${:import(java.util.Map.Entry)}
for (Entry<${keyType:argType(map, 0)}, ${valueType:argType(map, 1)}> ${entry} : ${map:var(java.util.Map)}.entrySet())
{
    ${keyType} ${key} = ${entry}.getKey();
    ${valueType} ${value} = ${entry}.getValue();
    ${cursor}
}

생성 된 코드 :

for (Entry<String, String> entry : properties.entrySet())
{
    String key = entry.getKey();
    String value = entry.getValue();
    |
}

의 경우 log멤버 변수에 추가하는 데 도움이되는 작은 내용입니다.

private static Log log = LogFactory.getLog(${enclosing_type}.class);

Mockito를 사용하여 모의 객체를 만듭니다 ( "Java 명령문"컨텍스트에서).

${:importStatic('org.mockito.Mockito.mock')}${Type} ${mockName} = mock(${Type}.class);

그리고 "자바 유형 멤버"에서 :

${:import(org.mockito.Mock)}@Mock
${Type} ${mockName};

예외를 발생시키기 위해 void 메소드를 조롱하십시오.

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}
doThrow(${RuntimeException}.class).when(${mock:localVar}).${mockedMethod}(${args});

뭔가를하기 위해 void 메소드를 조롱하십시오 :

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) throws Throwable {
    Object arg1 = invocation.getArguments()[0];
    return null;
}
}).when(${mock:localVar}).${mockedMethod}(${args});

정확히 한 번 호출 된 모의 메소드를 확인하십시오.

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.times)}
verify(${mock:localVar}, times(1)).${mockMethod}(${args});

조롱 된 메소드가 호출되지 않았는지 확인하십시오.

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.never)}verify(${mock:localVar}, never()).${mockMethod}(${args});

Google Guava를 사용하는 새로운 링크 목록 (해시 셋 및 해시 맵과 유사) :

${import:import(java.util.List,com.google.common.collect.Lists)}List<${T}> ${newName} = Lists.newLinkedList();

또한 Test 클래스를 생성하는 거대한 템플릿을 사용합니다. 다음은 관심있는 모든 사용자가 사용자 정의해야하는 단편화 된 단편입니다.

package ${enclosing_package};

import org.junit.*;
import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.junit.runner.RunWith;

// TODO autogenerated test stub
@RunWith(MockitoJUnitRunner.class)
public class ${primary_type_name} {

    @InjectMocks
    protected ${testedType} ${testedInstance};
    ${cursor}

    @Mock
    protected Logger logger;

    @Before
    public void setup() throws Exception {
    }

    @Test
    public void shouldXXX() throws Exception {
        // given

        // when
        // TODO autogenerated method stub

        // then
        fail("Not implemented.");
    }
}
// Here goes mockito+junit cheetsheet

널 체크!

if( ${word_selection} != null ){
    ${cursor}
}

if( ${word_selection} == null ){
    ${cursor}
}

내 사랑하는 사람 중 하나는 foreach입니다 .

for (${iterable_type} ${iterable_element} : ${iterable}) {
    ${cursor}
}

그리고 추적에 많이 사용하기 때문에 traceout :

System.out.println("${enclosing_type}.${enclosing_method}()");

방금 다른 것을 생각하고 인터넷에서 언젠가 그것을 발견했습니다. const :

private static final ${type} ${name} = new ${type} ${cursor};

sysout에 대한 작은 팁-이름을 "sop"로 바꾸고 싶습니다. Java 라이브러리의 다른 항목은 "sop"으로 시작하지 않으므로 "sop"및 붐을 빠르게 입력 할 수 있습니다.

현재 범위 (illarg)에 변수가있는 IllegalArgumentException을 발생시킵니다.

throw new IllegalArgumentException(${var});

보다 나은

throw new IllegalArgumentException("Invalid ${var} " + ${var});  

코드 생성에 멋진 것은 아니지만 코드 검토에 매우 유용합니다.

템플릿 coderev low / med / high가 다음을 수행합니다.

/**
 * Code Review: Low Importance
 * 
 *
 * TODO: Insert problem with code here 
 *
 */

그런 다음 작업보기에서-회의 중에 제기 할 모든 코드 검토 주석을 표시합니다.

여기에 더 많은 템플릿이 있습니다 .

포함 사항 :

• 특정 날짜에서 날짜 개체를 만듭니다.
• 새로운 제네릭 ArrayList 만들기
• 로거 설정
• 지정된 수준으로 로그
• 새로운 제네릭 해시 맵 생성
• 지도를 반복하고 키와 값을 인쇄하십시오.
• SimpleDateFormat을 사용하여 시간 구문 분석
• 파일을 한 줄씩 읽으십시오
• 잡힌 예외를 기록하고 다시 던지기
• 코드 블록의 실행 시간 인쇄
• 주기적 타이머 생성
• 문자열을 파일에 쓰기

slf4j 로깅

${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}

private static final Logger LOGGER = LoggerFactory
    .getLogger(${enclosing_type}.class);

콩 속성

private ${Type} ${property};

public ${Type} get${Property}() {
    return ${property};
}

public void set${Property}(${Type} ${property}) {
    ${propertyChangeSupport}.firePropertyChange("${property}", this.${property},     this.${property} = ${property});
}

PropertyChangeSupport

private PropertyChangeSupport ${propertyChangeSupport} = new PropertyChangeSupport(this);${:import(java.beans.PropertyChangeSupport,java.beans.PropertyChangeListener)}
public void addPropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(listener);
}

public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(propertyName, listener);
}

public void removePropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(listener);
}

public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(propertyName, listener);
}

Java 7 이후로, 엔 클로징 클래스에 대한 정적 참조가 필요한 (또는 선호하는) 로거를 설정하는 좋은 방법은 새로 도입 된 MethodHandles API를 사용하여 정적 컨텍스트에서 런타임 클래스를 얻는 것입니다.

SLF4J의 예제 스 니펫은 다음과 같습니다.

private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

IDE에서 간단한 스 니펫을 제외하고 실수로 클래스 이름을 가지고 있지 않기 때문에 특정 기능을 다른 클래스로 리팩토링하면 취성이 적습니다.

GUI 스레드에서 코드 호출

slaterGUI 스레드에서 코드를 신속하게 디스패치 하기 위해 다음 템플릿을 바로 가기 에 바인딩합니다 .

${:import(javax.swing.SwingUtilities)}
SwingUtilities.invokeLater(new Runnable() {      
      @Override
      public void run() {
        ${cursor}
      }
    });

코드로 테스트 할 때 때로는 일부 syso 를 삭제하지 못했습니다 . 그래서 나는 스스로 syt 라는 템플릿을 만들었습니다 .

System.out.println(${word_selection}${});//${todo}:remove${cursor}

컴파일하기 전에 항상 TODO를 확인하고 System.out을 다시 삭제하는 것을 잊지 않습니다.

strf -> String.format("msg", args) 아주 간단하지만 약간의 타이핑을 저장합니다.

String.format("${cursor}",)

현재 디스플레이에서 SWT 색상을 가져옵니다.

Display.getCurrent().getSystemColor(SWT.COLOR_${cursor})

syncexec를 가진 서라운드

PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
    public void run(){
        ${line_selection}${cursor}
    }
});

싱글 톤 디자인 패턴을 사용하십시오.

/**
 * The shared instance.
 */
private static ${enclosing_type} instance = new ${enclosing_type}();

/**
 * Private constructor.
 */
private ${enclosing_type}() {
    super();
}

/**
 * Returns this shared instance.
 *
 * @returns The shared instance
 */
public static ${enclosing_type} getInstance() {
    return instance;
}

그리고 equalsbuilder, hashcodebuilder adaptation :

${:import(org.apache.commons.lang.builder.EqualsBuilder,org.apache.commons.lang.builder.HashCodeBuilder)}
@Override
public boolean equals(Object obj) {
    return EqualsBuilder.reflectionEquals(this, obj);
}

@Override
public int hashCode() {
    return HashCodeBuilder.reflectionHashCode(this);
}

로거 선언의 템플릿은 훌륭합니다.

또한 내가 더 자주 사용하는 로그 수준에 대해 linfo, ldebug, lwarn, lerror를 만듭니다.

오류 :

logger.error(${word_selection}${});${cursor}

이벤트에 대한 모든 것을 만듭니다

이벤트는 Java에서 작성하기가 다소 어려우므로 모든 인터페이스, 메소드 및 하나의 이벤트에 대해서만 작성하는 것이므로 1 개의 이벤트에 필요한 모든 것을 작성하는 간단한 템플릿을 만들었습니다.

${:import(java.util.List, java.util.LinkedList, java.util.EventListener, java.util.EventObject)}

private final List<${eventname}Listener> ${eventname}Listeners = new LinkedList<${eventname}Listener>();

public final void add${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.add(listener);
    }
}

public final void remove${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.remove(listener);
    }
}

private void raise${eventname}Event(${eventname}Args args)
{
    synchronized(${eventname}Listeners) {
        for(${eventname}Listener listener : ${eventname}Listeners)
            listener.on${eventname}(args);
    }
}

public interface ${eventname}Listener extends EventListener
{
    public void on${eventname}(${eventname}Args args);
}

public class ${eventname}Args extends EventObject
{
    public ${eventname}Args(Object source${cursor})
    {
        super(source);
    }
}

당신이 하나를 공유하는 이벤트가있는 경우 EventObject, 다만 템플릿에 의해 삽입 된 사용자를 삭제하고의 해당 부분을 변경 raise___()하고 on____().

제네릭 인터페이스와 제네릭 클래스를 사용하여 멋지고 작고 우아한 이벤트 메커니즘을 작성했지만 Java가 제네릭을 처리하는 방식으로 인해 작동하지 않습니다. = (

편집 : 1) 이벤트가 진행되는 동안 스레드가 리스너를 추가 / 제거하는 문제가 발생했습니다. 을 List사용하므로 I 첨가 동안 수정할 수없는 synchronized리스트 자체 잠금 청취자의리스트를 액세스 또는 사용중인 블록.

테스트 방법을 제공해야 할 때 삽입

나는 아주 좋은 개발자 및 친구와 쌍으로 프로그래밍하면서 최근에 이것과 비슷한 버전을 보았고,이 목록에 추가 할 수 있다고 생각합니다.

이 템플릿은 다음, 클래스에 새로운 시험 방법을 만들 것입니다 감안할 때 - 그리고 접근 - 언제 으로부터 행위 주도 개발 구조화 코드에 대한 가이드로, 코멘트에 (BDD) 패러다임. 메소드 이름을 "should"로 시작하고 나머지 더미 메소드 이름 "CheckThisAndThat"을 테스트 메소드 책임에 대한 가능한 최상의 설명으로 대체 할 수 있습니다. 이름을 입력 한 후 TAB은로 바로 이동 // Given section하므로 사전 조건 입력을 시작할 수 있습니다.

"tst"라는 세 글자로 매핑되었고, "Test methods should-gven-when-then";)

내가봤을 때와 마찬가지로 유용하다고 생각합니다.

@Test
public void should${CheckThisAndThat}() {
    Assert.fail("Not yet implemented");
    // Given
    ${cursor}

    // When


    // Then

}${:import(org.junit.Test, org.junit.Assert)}

스프링 주입

나는 이것이 게임에 늦었다는 것을 알고 있지만, 여기 클래스에서 Spring Injection에 사용하는 것이 있습니다.

${:import(org.springframework.beans.factory.annotation.Autowired)}
private ${class_to_inject} ${var_name};

@Autowired
public void set${class_to_inject}(${class_to_inject} ${var_name}) {
  this.${var_name} = ${var_name};
}

public ${class_to_inject} get${class_to_inject}() {
  return this.${var_name};
}

다음은 인스턴스화 할 수없는 클래스의 생성자입니다.

// Suppress default constructor for noninstantiability
@SuppressWarnings("unused")
private ${enclosing_type}() {
    throw new AssertionError();
}

이것은 맞춤 예외입니다.

/**
 * ${cursor}TODO Auto-generated Exception
 */
public class ${Name}Exception extends Exception {
    /**
     * TODO Auto-generated Default Serial Version UID
     */
    private static final long serialVersionUID = 1L;    

    /**
     * @see Exception#Exception()
     */
    public ${Name}Exception() {
        super();
    }

    /**
     * @see Exception#Exception(String) 
     */
    public ${Name}Exception(String message) {
        super(message);         
    }

    /**
     * @see Exception#Exception(Throwable)
     */
    public ${Name}Exception(Throwable cause) {
        super(cause);           
    }

    /**
     * @see Exception#Exception(String, Throwable)
     */
    public ${Name}Exception(String message, Throwable cause) {
        super(message, cause);
    }
}

나는 다음과 같이 생성 된 클래스 주석을 좋아한다.

/**
 * I... 
 * 
 * $Id$
 */

"I ..."는 즉시 개발자가 클래스의 기능을 설명하도록 권장합니다. 문서화되지 않은 클래스의 문제를 개선하는 것 같습니다.

물론 $ Id $는 유용한 CVS 키워드입니다.

이 스 니펫을 많이 사용하여 null값과 빈 문자열을 찾았습니다 .

"인수 테스트"-템플릿을 메소드의 첫 번째 코드로 사용하여 수신 된 인수를 확인합니다.

testNull 인수

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}

회사 또는 프로젝트 표준에 맞게 예외 메시지를 변경할 수 있습니다. 그러나 문제가되는 인수의 이름이 포함 된 메시지를 사용하는 것이 좋습니다. 그렇지 않으면 메소드의 호출자가 코드에서 잘못된 점을 이해해야합니다. ( NullPointerException메시지가없는 A 는 의미가없는 메시지 "null"을 제외하고 예외를 생성합니다).

testNullOrEmptyStringArgument

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

위에서 null 확인 템플릿을 재사용하고이 스 니펫을 구현하여 빈 문자열 만 확인하면됩니다. 그런 다음이 두 템플릿을 사용하여 위 코드를 생성합니다.

그러나 위의 템플릿은 in 인수가 final 인 경우 생성 된 코드를 수정해야한다는 문제가 있습니다 ( ${varName} = ${varName}.trim()실패).

많은 최종 인수를 사용하고 빈 문자열을 확인하려고하지만 코드의 일부로 자르지 않아도되는 경우 대신 다음을 수행하십시오.

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
if (${varName}.trim().isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

testNullFieldState

또한 인수로 보내지지 않은 변수를 검사하기위한 스 니펫을 만들었습니다 (큰 차이점은 예외 유형이며 이제는 IllegalStateException대신입니다).

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}

testNullOrEmptyStringFieldState

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field " +
            "cannot be an empty string: ${varName}");
}

testArgument

변수를 테스트하기위한 일반적인 템플릿입니다. 이것을 이해하는 법을 배우는 데 몇 년이 걸렸습니다. 이제 많이 사용합니다 (위의 템플릿과 함께 사용하십시오!)

if (!(${varName} ${testExpression})) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument ${varName} (" + ${varName} + ") " +
        "did not pass the test: ${varName} ${testExpression}");
}

값을 반환하는 피연산자 ( "==", "<", ">"등)와 다른 값 또는 변수를 반환하는 변수 이름 또는 조건을 입력하면 테스트에 실패하면 결과 코드에서 IllegalArgumentException이 발생합니다.

전체 표현식이 "! ()"로 묶인 약간 복잡한 if 절의 이유는 예외 메시지에서 테스트 조건을 재사용 할 수 있도록하기위한 것입니다.

어쩌면 동료를 혼란스럽게 할 것입니다. 그러나 코드를 봐야만하는 경우에만 이러한 종류의 예외를 throw하면 필요하지 않을 수도 있습니다 ...

다음은 배열을 사용한 예입니다.

public void copy(String[] from, String[] to) {
    if (!(from.length == to.length)) {
        throw new IllegalArgumentException(
                "Illegal argument. The argument from.length (" +
                            from.length + ") " +
                "did not pass the test: from.length == to.length");
    }
}

"from.length"[TAB] "== to.length"를 입력하여 템플릿을 불러 와서이 결과를 얻습니다.

결과는 "ArrayIndexOutOfBoundsException"또는 이와 유사한 방법보다 더 재미 있으며 실제로 사용자에게 문제를 파악할 수있는 기회를 제공 할 수 있습니다.

즐겨!

MessageFormat에 사용합니다 (Java 1.4 사용). 그렇게하면 국제화를 수행 할 때 추출하기 어려운 연결이 없다고 확신합니다.

i18n

String msg = "${message}";
Object[] params = {${params}};
MessageFormat.format(msg, params);

로깅에도 :

로그

if(logger.isDebugEnabled()){
  String msg = "${message}"; //NLS-1
  Object[] params = {${params}};
  logger.debug(MessageFormat.format(msg, params));
}

내가 가장 좋아하는 몇 가지는 ...

1 : Javadoc, Spring 객체 주입 방법 인 메소드에 대한 문서를 삽입하십시오.

 Method to set the <code>I${enclosing_type}</code> implementation that this class will use.
* 
* @param ${enclosing_method_arguments}<code>I${enclosing_type}</code> instance 

2 : 디버그 창, FileOutputStream을 작성하고 버퍼의 내용을 파일에 씁니다. 버퍼를 과거 실행과 비교하고 (BeyondCompare 사용) 버퍼가 너무 커서 버퍼의 내용을 볼 수없는 경우 (검사를 통해)에 사용됩니다 ...

java.io.FileOutputStream fos = new java.io.FileOutputStream( new java.io.File("c:\\x.x"));
fos.write(buffer.toString().getBytes());
fos.flush();
fos.close();