올해는 머신러닝이다.

일단 svn 저장소는 최신 소스를 유지하는 trunk가 있고 trunk에서 분리되어 나온 branch라는 것이 있습니다

이름만 다를 뿐 실제로는 각각 하나의 디렉토리라고 보셔도 됩니다.

개발 팀마다 svn저장소를 사용하는 방법이 조금씩 다르기 때문에

어떻게 사용하는 것이 맞다고 말씀드리긴 힘듭니다.

제가 사용하는 방법을 예를 들어보겠습니다.

HelloWorld라는 프로젝트를 SVN저장소에 생성합니다.

그리고 프로젝트의 소스들을 trunk에 저장합니다.

해당 프로젝트에 A라는 기능을 추가하기로 결정되었습니다.

그러면 trunk에 있는 최신 소스를 그대로 복사하여 A라는 branch를 생성합니다.

이 시점에서 trunk와 A branch는 동일합니다.

이제 A에 있는 소스들을 여러사람이 함께 수정합니다.

기능 추가가 완료되면 A에서 변경된 소스들을 trunk와 병합합니다.

이것을 merge라고 합니다. 

그러면 trunk는 다시 A기능이 추가된 최신소스가 됩니다.

이제 다시 HelloWorld프로젝트에 B라는 기능을 추가해야 합니다.

그러면 또 trunk의 소스를 그대로 복사하여 B라는 branch를 생성합니다.

그리고 B branch에 기능을 추가하고 완료되면 B기능에서 변경된 소스를 trunk로 merge합니다.

이것이 계속 반복되면서 trunk는 항상 최신소스로 유지가 됩니다.

SVN의 진정한 기능은 두 개 이상의 기능추가가 동시에 진행되어야 할 때 발휘됩니다.

즉 A, B라는 두 개의 기능을 추가해야 하는데 두 개의 작업이

서로 다른 팀에 의해서 동시에 진행된다고 가정합니다.

그러면 branch를 하나 생성해서 서로 같은 소스를 수정하다보면 버그가 발생해도

이게 A기능때문에 생긴 버그인지 B기능때문에 생긴 버그인지 알기가 힘들고 유지보수도 힘들어집니다.

그래서 trunk에서 branch를 두 개 생성하여 각각 따로 기능 추가를 합니다.

그리고 각각 작업이 완료되면 변경된 부분만 trunk로 merge합니다.

이렇게 되면 여러개의 작업이 동시에 진행되도 각각 서로 분리된 소스로 작업을 할 수 있게 됩니다.

일단 위 내용이 SVN의 대략적인 개념입니다.

이제 질문자님께서 질문하신 것에 대하여 이야기해보겠습니다.

파일을 수정하여 변경사항을 SVN 저장소에 반영하는 것을 commit 한다고 합니다.

최초에 프로젝트의 trunk를 checkout받아서 파일을 수정하다 보면 다른 사람이 해당 파일을 수정하여

commit하는 경우가 매우 자주 발생합니다.

commit은 소스 전체가 되는 것이 아니라 변경된 부분만 되는 것이기 때문에

질문자님은 update라는 명령을 사용하시면 변경된 부분만 최신 소스로 업데이트하실 수 있습니다.

매번 새로 checkout받으실 필요가 없다는 말입니다.

그런데 이때 같은 부분을 고치고 있었다면 conflict, 즉 충돌이 발생하게 됩니다.

충돌이 발생하면 해당 부분을 적절히 수정하여 충돌을 해제할 수 있습니다.

대략적인 감이 잡히셨는지 모르겠네요.

svn에 관한 검색을 하셔서 잘 정리된 페이지를 쭉 한 번 읽어보시길 추천드립니다

NIO가 무엇일까요?  
NonBloking Input-Output 입니다. 기존의 일반 IO는 항상 블럭화가 되면서, 처리를 해왓습니다.
블럭화가되면 그블럭이 풀리기전까진 아무것도  수행할수 없지요. 그래서 그것이 큰 단점이기도 하지요.
NIO는 JDK 1.4 이전에는 존재 하지 않는 방법론입니다. 그 이후에 생긴 방법론이므로 참고 하시면 되구요.
어쨋든 그래서 NIO가 무엇이냐면.. 블럭화(잠수)를 타지않고 작업을 할수있게 해주는 방법론이에요.
서버가 존재하고 통신을 할때 메인스레드가 블럭화(잠수)를 타버리면 그 블럭화가 풀리기전까진 아무것도 못하잖아요..?
이것은 블럭을 시키지않고서, 누가 들어오던지 자료를 요청하던지 블럭 시키지않고 그냥 무작정 일만 처리시키는것이죠.

하나  이상적인 예를 들어볼가요?

출처 : http://blog.naver.com/skyadult?Redirect=Log&logNo=20025986907

SequenceInputStream(InputStream first, InputStream second) 
SequenceInputStream(Enumeration streamEnum)

Operationally, the class fulfills read requests from the first InputStream until it runs out and then switches over to the second one. In the case of an Enumeration, it will continue through all of theInputStreams until the end of the last one is reached. Here is a simple example that uses aSequenceInputStream to output the contents of two files:

// Demonstrate sequenced input. 
import java.io.*; 
import java.util.*; 
class InputStreamEnumerator implements Enumeration { 
private Enumeration files; 
public InputStreamEnumerator(Vector files) { 
this.files = files.elements(); 
} 
public boolean hasMoreElements() { 
return files.hasMoreElements(); 
} 
public Object nextElement() { 
try { 
return new FileInputStream(files.nextElement().toString()); 
} catch (Exception e) { 
 

This example creates a Vector and then adds two filenames to it. It passes that vector of 
names to the InputStreamEnumerator class, which is designed to provide a wrapper on 
the vector where the elements returned are not the filenames but rather open 
FileInputStreams on those names. The SequenceInputStream opens each file in turn, 
and this example prints the contents of the two files.

출처 : http://stackoverflow.com/questions/1197729/retrieve-post-parameters-only-java

public boolean isInQuery(HttpServletRequest request, String key) {

  String query = request.getQueryString();

  String[] nameValuePairs = query.split("&");

  for(String nameValuePair: nameValuePairs) {

    if(nameValuePair.startsWith(key + "=")) {

      return true;

    }

  }

  return false;

}

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import javax.naming.Context;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;
import javax.naming.ldap.InitialLdapContext;
import javax.naming.ldap.LdapContext;

public class ADAuthenticator
{
  private String domain;
  private String ldapHost;
  private String searchBase;

  public ADAuthenticator()
  {
    this.domain = "<your domain>";
    this.ldapHost = "ldap://<your AD controller>";
    this.searchBase = "your AD root e.g. dc=abbl,dc=org";
  }

  public ADAuthenticator(String domain, String host, String dn)
  {
    this.domain = domain;
    this.ldapHost = host;
    this.searchBase = dn;
  }

  public Map authenticate(String user, String pass)
  {
    String returnedAtts[] ={ "sn", "givenName", "mail" };
    String searchFilter = "(&(objectClass=user)(sAMAccountName=" + user + "))";

    //Create the search controls
    SearchControls searchCtls = new SearchControls();
    searchCtls.setReturningAttributes(returnedAtts);

    //Specify the search scope
    searchCtls.setSearchScope(SearchControls.SUBTREE_SCOPE);

    Hashtable env = new Hashtable();
    env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
    env.put(Context.PROVIDER_URL, ldapHost);
    env.put(Context.SECURITY_AUTHENTICATION, "simple");
    env.put(Context.SECURITY_PRINCIPAL, user + "@" + domain);
    env.put(Context.SECURITY_CREDENTIALS, pass);

    LdapContext ctxGC = null;

    try
    {
      ctxGC = new InitialLdapContext(env, null);
      //Search objects in GC using filters
      NamingEnumeration answer = ctxGC.search(searchBase, searchFilter, searchCtls);
      while (answer.hasMoreElements())
      {
        SearchResult sr = (SearchResult) answer.next();
        Attributes attrs = sr.getAttributes();
        Map amap = null;
        if (attrs != null)
        {
          amap = new HashMap();
          NamingEnumeration ne = attrs.getAll();
          while (ne.hasMore())
          {
            Attribute attr = (Attribute) ne.next();
            amap.put(attr.getID(), attr.get());
          }
          ne.close();
        }
          return amap;
      }
    }
    catch (NamingException ex)
    {
      ex.printStackTrace();
    }

    return null;
  }
  
  public static void main(String[] args) {
  ADAuthenticator ada = new ADAuthenticator("jinsub.com", "ldap://*****", "dc=jinsub,dc=com");
  Map umap = ada.authenticate("userid", "userpassword");
  if (umap == null)
  System.out.println("login failed");
  else {
   System.out.println("login succ");
  // umap has three attributes: sn, givenName, mail
  }
 }
}

AD(ldap) 테스트용 Java 코드

출처 : http://cafe.naver.com/ccjmaster.cafe?iframe_url=/ArticleRead.nhn%3Farticleid=133

=========================================================================================

자바에서 처리하는 입력과 출력은 스트림(Stream)에 의존하다.

다시 말해 모든 형태의 입력과 출력은 1byte의 흐름으로 이루어져 있다는 이야기이다.

그런데 이러한 작업 처리를 텍스트 기반으로 한 형태로 바꿔 준다든지, 객체 기반으로 한 형태로 바꾸어 준다든지 하는 클래스가 있다.

우리는 먼저 1byte의 기본 입력과 출력 클래스 몇 가지를 공부하고 다음으로 각 형태로 변경시키는 클래스를 살펴보도록 할 것이다.

우선 1byte의 입력과 출력 기본 클래스는 InputStream과 OutputStream이다. 각 클래스의 상속관계는 다음과 같다.

  OutputStream

    ▶ FileOutputStream

    ▶ ByteArrayOutputStream

    ▶ PipedOutputStream

    ▶ ObjectOutputStream

    ▶ FilterOutputStream - BufferedOutputStream

    ▶ PaintStream

    ▶ DataOutputStream

  InputStream

    ▶ FileInputStream

    ▶ ByteArrayInputStream

    ▶ PipedInputStream

    ▶ ObjectInputStream

    ▶ SequenceInputStream

    ▶ AudioInputStream

    ▶ StringBufferInputStream

    ▶ FilterInputStream - BufferedInputStream

    ▶ LineNumberInputStream

         ▶ PushbackInputStream

         ▶ DataInputStream

여기에 표시된 많은 클래스를 다 공부한다는 것은 우리가 배우고자 하는 범위를 벗어나는 것이므로

실제로 파일 입·출력에서 많이 쓰는 형식을 한 가지씩만 외우도록 하자.

1byte 출력

  (1) 콘솔 출력용

    FileOutputStream fos = new FileOutputStream(FileDescriptor.out);
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    DataOutputStream dos = new DataOutputStream(bos);

    dos.write…
 

  (2) 파일 출력용  
    File file = new File("파일명");
    FileOutputStream fos = new FileOutputStream(file);
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    DataOutputStream dos = new DataOutputStream(bos);

    dos.write…
  

  (3) 네트워크 출력용
    Socket soc = new Socket(…);
    BufferedOutputStream bos = new BufferedOutputStream(soc.getOutputStream());
    DataOutputStream bos = new DataOutputStream(bos);

    dos.write…

1byte 입력

  (1) 콘솔 입력용

    FileInputStream fis = new FileInputStream(FileDescriptor.in);
    BufferedInputStream bis = new BufferedInputStream(fis);
    DataInputStream dis = new DataInputStream(bis);
    dis.read()…
  

  (2) 파일 입력용
    File file = new File("파일명");
    FileInputStream fis = new FileInputStream(file);
    BufferedInputStream bis = new BufferedInputStream(fis);
    DataInputStream dis = new DataInputStream(bis);
    dis.read()…
  

  (3) 네트워크 입력용
    Socket soc = new Socket(…);
    BufferedInputStream bis = new BufferedInputStream(soc.getInputStream());
    DataInputStream bis = new DataInputStream(bis);
    dis.read()…

이제 간단한 형태의 입·출력 예제를 처리해 보도록 하자.

EX 01

import java.io.*;

public class Java {
  public static void main(String[] args) {
    File file = new File("C:\\java\\work\\abc.txt"); // C:\\java\\work\\abc.txt 에 대한 객체를 생성한다.
    try {
      FileOutputStream fos = new FileOutputStream(FileDescriptor.out); // 콘솔에 대한 출력 스트림을 생성한다.
      FileOutputStream fos1 = new FileOutputStream(file); // 파일에 대한 출력 스트림을 생성한다.
      byte[] data = {66, 68, 70, 72, (byte) '!'}; // B, D, F, H, ! 에 대한 배열을 생성한다.
      fos.write(data);
      fos1.write(data);
      // fos.close();
      // fos1.close();
    }catch(FileNotFoundException fnfe){
      System.err.println("파일을 못찾겠다.");
      System.exit(1);
    }catch(IOException io){
      System.err.println("파일 입출력 에러");
      System.exit(1);
    }
    System.out.println("실행 끝");
  }
}

EX 02

import java.io.*;

public class Java {
  public static void main(String[] args) throws FileNotFoundException, IOException{
    /*
    FileInputStream fis = new FileInputStream(FileDescriptor.in); // 키보드로부터 입력 객체를 생성한다.
    System.out.print("입력 = ");
    byte by = fis.read(); 
    */ 
    File file = new File("C:\\java\\work\\abc.txt"); // 파일로부터의 입력 객체를 생성한다.

    FileInputStream fis = new FileInputStream(file);  
    byte[] by = new byte[65536];
    int count = fis.read(by);
    for(int i = 0; i < count; i++){
      System.out.println(i + " : " + (char)by[i]);
    }
  }
}

EX03

import java.io.*;

public class Java {
  public static void main(String[] args) throws FileNotFoundException, IOException{
   

   /*

    < DataOutputStream을 풀어서 썼을 때의 코딩>
       File file = new File("c:\\java\\work");
       FileOutputStream fos = new FileOutputStream(file);
       BufferedOutputStream bos = new BufferedOutputStream(fos); // 512byte
       DataOutputStream dos = new DataOutputStream(bos);
   */
  
    // 1byte 출력을 위한 객체
    DataOutputStream dos1 = new DataOutputStream(new BufferedOutputStream(new FileOutputStream

    (new File(new File  "c:\\java\\wordk"),"HJH.txt")))); // 파일에 대한 출력 객체를 생성
    dos1.writeInt(23); // int형 숫자를 출력한다. 이것은 출력하면 파일에는 4byte의 영역을 확보하고 데이터가 표시된다.

                             // 그래서 결과가 이상하게 보인다.
    dos1.writeDouble(12.345); // double형 숫자를 출력한다. 역시 int형과 마찬가지로 8byte의 영역을 확보 후 데이터 표시
    dos1.writeBytes("ABCDEFG"); // 1byte씩 문자 형태로 출력한다. 정상적으로 보인다.

    dos1.close();
  }
}

EX04

import java.io.*;

public class Java {
  public static void main(String[] args) {
    DataInputStream dis1 = null;
    try{
      dis1 = new DataInputStream(new BufferedInputStream(new FileInputStream

      (new File(new File("c:\\java\\wordk"),"HJH.txt")))); // DataInputStream 입력 객체를 생성한다.
    } catch (FileNotFoundException fnfe){}
    int a = 0;
    double b = 0.0;
    byte[] c = null;
    try{
      a = dis1.readInt(); // int형 데이터를 입력받는다. 처음 4byte를 입력받아 저장해 둔다.
      b = dis1.readDouble(); // double형으로 데이터를 입력받는다. 다음 8byte를 입력받아 double형으로 변환한다.
      c = new byte[10]; // 문자 배열을 선언한 후 그곳에 결과를 입력받는다.
    dis1.read(c);
    dis1.close();
    }catch(IOException ie){}
   
    System.out.println("a = " + a);
    System.out.println("b = " + b);
    System.out.println("c = " + new String(c));
  }
}