Commits

Yong Choi  committed 98e6a8c

Translating JSR-223 section in chapter 10

  • Participants
  • Parent commits f1b4fa6

Comments (0)

Files changed (1)

File JythonAndJavaIntegration.rst

-Chapter 10: Jython and Java Integration
-+++++++++++++++++++++++++++++++++++++++
+10장. 자이썬과 자바 통합
+++++++++++++++++++++++++
 
-Java integration is the heart of Jython application development.
-Most Jython developers are either Python developers that are
-looking to make use of the vast library of tools that the JVM has
-to offer, or Java developers that would like to utilize the Python
-language semantics without migrating to a completely different
-platform. The fact is that most Jython developers are using it so
-that they can take advantage of the vast libraries available to the
-Java world, and in order to do so there needs to be a certain
-amount of Java integration in the application. Whether you plan to
-use some of the existing Java libraries in your application, or
-you're interested in mixing some great Python code into your Java
-application, this chapter is geared to help with the integration.
+자바와의 통합은 자이썬 애플리케이션 개발의 심장이라 할 수 있다.
+대부분의 자이썬 개발자들은 파이썬 개발자 또는 자바 개발자로서, JVM이 제공하는 매우 다양한 도구들을 활용하는 방법을 모색하고 있거나, 혹은 완전히 다른 환경으로 옮겨가지 않으면서도 파이썬 언어의 장점을 취하고자 하는 사람들이다.
+대부분의 자이썬 개발자들은 자바 세계의 방대한 라이브러리를 활용하는 이점 때문에, 그리고 애플리케이션에서 어느 정도 자바 통합의 필요가 있기 때문에 자이썬을 사용하고 있는 것이 사실이다.
+당신의 응용 프로그램에서 기존 자바 라이브러리의 일부를 사용하려는 경우나, Java 응용 프로그램에 몇 가지 큰 파이썬 코드를 혼합하는데 관심이 있는 경우에는, 이 장이 큰 도움이 될 것이다.
 
-This chapter will focus on integrating Java and Python, but it will
-explore several different angles on the topic. You will learn
-several techniques to make use Jython code within your Java
-applications. Perhaps you'd like to simplify your code a bit; this
-chapter will show you how to write certain portions of your code in
-Jython and others in Java so that you can make code as simple as
-possible.
+이 장에서는 자바와 파이썬의 통합에 초점을 두는 한편, 그에 대한 다양한 각도의 접근을 모색할 것이다.
+당신은 당신의 자바 애플리케이션 내에서 사용하는 자이썬 코드를 만들기 위해 몇 가지 기술을 배우게된다.
+여러분은 자신의 코드를 좀 단순화하고 싶다고 느낄 때가 있을 것이다. 이 장에서는 어떻게 당신은 가능한 한 간단하게 코드를 만들 수 있도록 자바에서 자이썬과 다른 코드의 특정 부분을 작성하는 방법을 보여준다.
 
-You'll also learn how to make use of the many Java libraries within
-your Jython applications while using Pythonic syntax! Forget about
-coding those programs in Java: why not use Jython so that the Java
-implementations in the libraries are behind the scenes? This
-chapter will show how to write Python code and use the libraries
-directly from it.
+당신은 또한 파이썬다운 구문을 사용하는 동안 당신의 자이썬 애플리케이션 내에서 많은 자바 라이브러리의 사용을 만드는 방법을 배울것이다.이러한 프로그램을 자바에서 코딩하는 것은 잊어버려라. 자이썬을 사용하면 라이브러리의 자바 구현은 무대 뒤에서 이루어지도록 할 수 있지 않은가?
+이 장에서는 어떻게 파이썬 코드를 작성하고, 그 코드로 직접 라이브러리를 사용하는 법을 보여줄것이다.
 
-Using Java Within Jython Applications
-=====================================
+자이썬 애플리케이션 내에서 자바 사용하기
+========================================
 
-Making use of Java from within Jython applications is about as
-seamless as using external Jython modules within a Jython script.
-As you learned in Chapter 8, you can simply import the required
-Java classes and use them directly. Java classes can be called in
-the same fashion as Jython classes, and the same goes for method
-calling. You simply call a class method and pass parameters the
-same way you'd do in Python.
+자이썬 애플리케이션에서 자바를 활용하는 것은, 자이썬 스크립트에서 자이썬 모듈을 사용하는 것처럼 원활하게 이루어진다.
+8장에서 배운대로, 단순히 필요한 자바 클래스를 가져와서 직접 사용할 수 있다.
+자바 클래스는 자이썬 클래스와 같은 방식으로 호출할 수 있으며, 마찬가지로 메소드도 호출할 수 있다.
+당신은 파이썬에서 했던 방식으로 클래스 메소드를 호출하고 매개 변수를 전달한다.
 
-Type coercion occurs much as it does when using Jython in Java in
-order to seamlessly integrate the two languages. In the following
-table, you will see the Java types that are coerced into Python
-types and how they match up. Table 10-1 was taken from the Jython
-user guide.
+강제 변형\ *Type coercion*\ 은 두 언어를 완벽하게 통합하기위해 자바에서 자이썬을 사용할때 많이 발생한다.
+다음 표에서, 당신은 파이썬 형식들로 자바 유형들을 강제 변형하고, 그것들을 어떻게 짝짓는지 볼 수 있다.
+표 10-1은 자이썬 사용자 안내서에서 발췌한 것이다.
 
-**Table 10-1.** Python and Java Types
+** 10-1. 파이썬과 자바의 유형**
 
 ==================================  =====================================================================
-Java Type                           Python Type  
+자바 유형                           파이썬 유형 
 ==================================  =====================================================================
-char                                String(length of 1)                                     
+char                                String(길이가 1)                                     
 boolean                             Integer(true = not zero)                                
 byte, short, int, long              Integer  
 java.lang.String, byte[], char[]    String     
 java.lang.Class                     JavaClass    
-Foo[]                               Array(containing objects of  class or subclass of Foo)  
+Foo[]                               Array(Foo 클래스 또는 하위 클래스의 객체를 포함)  
 java.lang.Object                    String       
-orb.python.core.PyObject            Unchanged  
-Foo                                 JavaInstance representing Java class Foo                
+orb.python.core.PyObject            변경되지 않음
+Foo                                 자바 클래스 Foo를 나타내는 JavaInstance
 ==================================  =====================================================================
 
-Another thing to note about the utilization of Java within Jython
-is that there may be some naming conflicts. If a Java object
-conflicts with a Python object name, then you can simply fully
-qualify the Java object in order to ensure that the conflict is
-resolved. Another technique which was also discussed in Chapter 8
-is making use of the 'as' keyword when importing in order to rename
-an imported piece of code.
+자이썬 내에서 자바 활용에 관해 알아둘 또 다른 한가지는 몇 가지 이름짓기 충돌이 있을 수 있다는 것이다.
+자바 개체가 파이썬 개체의 이름과 충돌한다면, 자바 개체에 대한 완전한 이름을 표기함으로써 충돌을 해결할 수 있다.
+또 다른 방법으로는 8장에서 논의한 
+'as' 키워드를 사용하여 import된 코드에 대하여 이름을 바꿀 수도 있다.
 
-In the next couple of examples, you will see some Java objects
-being imported and used from within Jython.
+다음에 나오는 몇가지 예제들에서, 자이썬내에서 자바 개체들을 불러오고, 사용하고 있는 것을 확인할 수 있다.
 
-Listing 10-1. Using Java in Jython
+예제 10-1. 자이썬에서 자바 사용하기
 ::
     
     >>> from java.lang import Math
     Hello
 
 
-Now let's create a Java object and use it from within a Jython
-application.
+자바 개체를 만든 것을 가지고, 자이썬 애플리케이션 내에서 사용해보도록 하자.
 
 *Beach.java*
 
 ::
     
     public class Beach {
-     
+    
         private String name;
         private String city;
-         
-         
+        
+        
         public Beach(String name, String city){
             this.name = name;
             this.city = city;
         }
-         
+        
         public String getName() {
             return name;
         }
     }
 
 
-Using Beach.java in Jython
+자이썬에서 Beach.java 사용
 ::
     
     >>> import Beach
     Cocoa Beach
 
 
-As we had learned in Chapter 8, one thing you'll need to do is
-ensure that the Java class you wish to use resides within your
-CLASSPATH. In the example above, I created a JAR file that
-contained the Beach class and then put that JAR on the CLASSPATH.
+8장에서 배운 것과 같이, 여러분이 할 일은 사용하고자하는 자바 클래스를 CLASSPATH에 두는 것이다. 위의 예제에서는 Beach 클래스를 포함하는 JAR 파일을 만들고, CLASSPATH에 JAR를 넣어두었다.
 
-It is also possible to extend or subclass Java classes via Jython
-classes. This allows us to extend the functionality of a given Java
-class using Jython objects, which can be quite helpful at times.
-The next example shows a Jython class extending a Java class that
-includes some calculation functionality. The Jython class then adds
-another calculation method and makes use of the calculation methods
-from both the Java class and the Jython class.
+또한, 자이썬의 클래스를 통해 자바 클래스들로 확장하거나 서브클래스화할 수 있다.
+이러면 자이썬 개체들을 사용하고 있는 주어진 자바 클래스의 기능성을 확장할 수 있고, 때때로 매우 도움이 된다. 
+다음 예제는 몇 가지 계산 기능을 포함하는 자바 클래스를 확장한 자이썬 클래스를 보여준다.
+자이썬 클래스는 다른 계산 메소드를 추가하고, 자바 클래스와 자이썬 클래스의 계산 메소드들을 사용한다.
 
-*Listing 10-2. Extending Java Classes*
+*예제 10-2. 자바 클래스 확장*
 
 **Calculator.java**
 ::
     
     /**
-    * Java calculator class that contains two simple methods
+    * 두 가지 간단한 메소드를 포함하는 자바 계산기 클래스
     */
     public class Calculator {
-     
+    
         public Calculator(){
-         
+        
         }
-         
+        
         public double calculateTip(double cost, double tipPercentage){        
             return cost * tipPercentage;
         }
     
     }
 
- 
+
 
 **JythonCalc.py**
 ::
     
     import Calculator
     from java.lang import Math
-     
+    
     class JythonCalc(Calculator):
         def __init__(self):
             pass
         
         def calculateTotal(self, cost, tip, tax):
             return cost + self.calculateTip(tip) + self.calculateTax(tax)
-     
+    
     if __name__ == "__main__":
         calc = JythonCalc()
         cost = 23.75
         print Math.round(calc.calculateTotal(cost, tip, tax))
 
 
-**Result**
+**결과**
 ::
     
     Starting Cost: 23.75
     Tax Percentage: 0.07
     29
 
-Using Jython Within Java Applications
-=====================================
+자바 애플리케이션 내에서 자이썬 사용하기
+========================================
 
-Often, it is handy to have the ability to make use of Jython from
-within a Java application. Perhaps there is a class that would be
-better implemented in Python syntax, such as a Javabean. Or maybe
-there is a handy piece of Jython code that would be useful within
-some Java logic. Whatever the case may be, there are several
-approaches you can use in order to achieve this combination of
-technologies. In this section, we'll cover some of the older
-techniques for using Jython within Java, and then go into the
-current and future best practices for doing this. In the end, you
-should have a good understanding for how to use a module, script,
-or even just a few lines of Jython within your Java application.
-You will also have an overall understanding for the way that Jython
-has evolved in this area.
+종종, 그것은 자바 애플리케이션 내에서 자이썬을 사용 할 수있는 능력을 가지고하는 것이 편리할 것이다.
+아마도 더 나은 자바빈즈 같은 파이썬 구문에 구현될 클래스가 있다.
+아니면 일부 자바 로직 이내에 유용하다고 자이썬 코드의 편리한 부분이 있다.
+어떤 경우이든 이러한 조합을 달성하기 위하여 사용할 수 있는 여러 가지 방법이 존재한다.
+이 섹션에서는, 자바와 함께 자이썬을 사용하는 오래된 기법을 다룬 다음, 현재와 앞으로의 모범 사례를 소개한다.
+끝에 가서는, 자이썬 모듈, 스크립트 또는 몇 줄의 코드를 자바 애플리케이션 내에서 사용하는 방법에 대한 이해를 얻게 될 것이다.
+또한 자이썬이 이러한 영역에서 어떻게 발전해왔는지에 대하여 전반적으로 이해하게 될 것이다.
 
-Object Factories
-----------------
+개체 팩토리
+-----------
 
-Perhaps the most widely used technique used today for incorporating
-Jython code within Java applications is the object factory design
-pattern. This idea basically enables seamless integration between
-Java and Jython via the use of object factories. There are
-different implementations of the logic, but all of them do have the
-same result in the end.
+오늘날 자바 애플리케이션 내에서 자이썬 코드를 통합하는 가장 널리 사용되는 기술은 아마도 개체 팩토리 디자인 패턴일 것이다.
+이 개념은 기본적으로 개체 팩토리의 사용을 통해 자바와 자이썬 사이의 원활한 통합을 가능하게 한다.
+논리의 서로 다른 구현이 있지만 그것들 모두 결국 같은 결과를 얻게 된다.
 
-Implementations of the object factory paradigm allow one to include
-Jython modules within Java applications without the use of an extra
-compilation step. Moreover, this technique allows for a clean
-integration of Jython and Java code through usage of Java
-interfaces. In this section, I will explain the main concept of the
-object factory technique and then I will show you various
-implementations.
+개체 팩토리 패러다임을 구현하면, 별도의 컴파일 단계를 거치지 않고도 자바 애클리케이션 내에 자이썬 모듈을 포함시킬 수 있다.
+또한, 이 기술은 자바 인터페이스의 사용을 통해 자이썬과 자바 코드를 깔끔하게 통합할 수 있도록 해준다.
+이 섹션에서는, 개체 팩토리 기술의 주요 개념을 설명한 후에 다양한 구현을 예시하도록 하겠다.
 
-Let's take a look at an overview of the entire procedure from a
-high level. Say that you'd like to use one of your existing Jython
-modules as an object container within a Java application. Begin by
-coding a Java interface that contains definitions for those methods
-contained in the module that you'd like to expose to the Java
-application. Next, you would modify the Jython module to implement
-the newly coded Java interface. After this, code a Java factory
-class that would make the necessary conversions of the module from
-a PyObject into a Java object. Lastly, take the newly created Java
-object and use it as you wish. It may sound like a lot of steps in
-order to perform a simple task, but I think you'll agree that it is
-not very difficult once you've seen it in action.
+전체적인 절차에 대한 개요를 살펴보도록 하자.
+기존의 자이썬 모듈을 자바 애클리케이션 내에서 개체 컨테이너로서 사용하고 싶다고 하자.
+자바 애플리케이션에 노출시키고자하는 모듈에 포함된 메소드들에 대한 정의를 담는 자바 인터페이스를 코딩하는 것부터 시작한다.
+다음으로, 새롭게 작성한 자바 인터페이스를 구현할 수 있도록 자이썬 모듈을 수정한다.
+다음으로, PyObject를 자바 개체로 변환해주는 자바 팩토리 클래스를 작성한다.
+최종적으로는, 새로 만든 자바 객체를 원하는대로 사용할 수 있다.
+간단한 작업을 위해 여러 단계를 거치는 것 같아보이겠지만, 한번 살펴보고나면 그리 어렵지는 않을 것이다.
 
-Over the next few sections, I will take you through different
-examples of the implementation. The first example is a simple and
-elegant approach that involves a one-to-one Jython object and
-factory mapping. In the second example, we'll take a look at a very
-loosely coupled approach for working with object factories that
-basically allows one factory to be used for all Jython objects.
-Each of these methodologies has its own benefit and you can use the
-one that works best for you.
+지금부터 몇 가지 예제를 살펴볼 것이다.
+첫 번째 예제는 일대일 자이썬 개체와 팩토리 매핑을 포함하는 간단하고 우아한 방법이다.
+두번째 예제에서는, 기본적으로 하나의 팩토리만으로 모든 자이썬 개체에 대하여 사용할 수 있는 개체 팩토리를 활용하는, 아주 느슨하게 결합하는 접근방법을 살펴볼 것이다.
+이러한 방법론 중에서 여러분에게 맞는 것을 취사선택할 수 있다.
 
-One-to-One Jython Object Factories
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+일대일 자이썬 개체 팩토리
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
-We will first discuss the notion of creating a separate object
-factory for each Jython object we wish to use. This one-to-one
-technique can prove to create lots of boilerplate code, but it has
-some advantages that we'll take a closer look at later on. In order
-to utilize a Jython module using this technique, you must either
-ensure that the .py module is contained within your sys.path, or
-hard code the path to the module within your Java code. Let's take
-a look at an example of this technique in use with a Java
-application that uses a Jython class representing a building.
+우리가 사용하고자 하는 각각의 자이썬 개체에 대하여 개별적인 개체 팩토리를 생성하는 것에 대하여 일단 논의하겠다.
+이러한 일대일 기술은 관용적인 코드를 많이 만들어내게 되는 경향이 있지만, 나중에 주목하게 될 만한 몇 가지 장점이 있다.
+이 기술을 사용하여 자이썬 모듈을 활용하기 위해서는, sys.path에 .py 모듈이 위치하도록 하거나, 모듈이 자바 코드 내에 있도록 경로를 하드 코드하여야 한다.
+건물을 나타내는 자이썬 클래스를 사용하는 자바 애플리케이션에 이 기법을 적용하는 예를 살펴보자.
 
-*Listing 10-3. Creating a One-To-One Object Factory*
+*예제 10-3. 일대일 개체 팩토리 만들기*
 
 **Building.py**
 ::
     
-    # A python module that implements a Java interface to
-    # create a building object
+    # 건물 개체를 생성하기 위하여 자바 인터페이스를
+    #  구현한 파이썬 모듈
     from org.jython.book.interfaces import BuildingType
-     
+    
     class Building(BuildingType):
         def __init__(self, name, address, id):
             self.name = name
             self.address = address
             self.id = id
-         
+        
         def getBuildingName(self):
             return self.name
-         
+        
         def getBuildingAddress(self):
             return self.address
-         
+        
         def getBuldingId(self):
             return self.id
 
-We begin with a Jython module named *Building.py* that is placed
-somewhere on our sys.path. Now, we must first ensure that there are
-no name conflicts before doing so or we could see some quite
-unexpected results. It is usually a safe bet to place this file at
-the source root for your application unless you explicitly place
-the file in your sys.path elsewhere. You can see that our
-*Building.py* object is a simple container for holding building
-information. We must explicitly implement a Java interface within
-our Jython class. This will allow the PythonInterpreter to coerce
-our object later. Our second piece of code is the Java interface
-that we implemented in *Building.py*. As you can see from the code,
-the returning Jython types are going to be coerced into Java types,
-so we define our interface methods using the eventual Java types.
-Let's take a look at the Java interface next.
+sys.path에 위치한 *Building.py*\ 라는 이름의 모듈에서부터 시작한다.
+그렇게 하기 이전에, 이름이 충돌되지 않는다는 것을 확실히 해두어야 예상치 못한 일이 벌어지는 결과를 피할 수 있다.
+파일을 명시적으로 sys.path 이외의 곳에 둔 것이 아니라면, 애플리케이션의 소스 루트에 두는 것이 대체로 안전할 것이다.
+*Building.py* 개체는 건물의 정보를 담는 단순한 컨테이너라는 것을 알 수 있다.
+우리는 명시적으로 우리의 자이썬 클래스 내에서 자바 인터페이스를 구현해야 한다.
+이는 PythonInterpreter로 하여금 개체를 나중에 강제 변형하도록 해준다.
+우리의 두번째 코드 조각은 *Building.py* 내에 구현한 자바 인터페이스이다. 코드에서 볼 수 있듯이, 반환되는 자이썬 형은 자바 형으로 강제 변형될 것이므로, 우리는 eventual 자바 형을 사용하여 인터페이스 메소드를 정의한다.
+다음으로는 이 자바 인터페이스를 살펴보자.
 
 **BuildingType.java**
 ::
     
-    // Java interface for a building object
+    // 건물 개체에 대한 자바 인터페이스
     package org.jython.book.interfaces;
-     
+    
     public interface BuildingType {
-     
+    
         public String getBuildingName();
         public String getBuildingAddress();
         public String getBuildingId();
-     
+    
     }
 
-Looking through the definitions contained within the Java
-interface, it is plain to see that the python module that
-subclasses it simply implements each of the definitions. If we
-wanted to change the python code a bit and add some code to one of
-the methods we could do so without touching the Java interface. The
-next piece of code that we need is a factory written in Java. This
-factory has the job of coercing the python module into a Java
-class.
+자바 인터페이스 내에 포함된 정의를 살펴보면, 그것을 서브클래스하는 파이썬 모듈이 각각의 정의를 단순히 구현한다는 것을 쉽게 알 수 있을 것이다.
+파이썬 코드를 약간 변형하여 메소드 중 하나에 코드를 조금 추가하고자 한다면 자바 인터페이스를 건드리지 않고도 그렇게 할 수 있다.
+다음으로 우리에게 필요한 코드 조각은 자바로 쓰여진 팩토리이다.
+이 팩토리는 자바 클래스로 파이썬 모듈을 강제 변형하는 작업을 하고 있다.
 
 **BuildingFactory.java**
 ::
     
     /**
      *
-     * Object Factory that is used to coerce python module into a
-     * Java class
+     * 파이썬 모듈을 자바 클래스로 강제 변형하는 데 사용되는
+     * 개체 팩토리
      */
     package org.jython.book.util;
-     
+    
     import org.jython.book.interfaces.BuildingType;
     import org.python.core.PyObject;
     import org.python.core.PyString;
     import org.python.util.PythonInterpreter;
-     
+    
     public class BuildingFactory {
-     
+    
         private PyObject buildingClass;
-         
+        
         /**
-         * Create a new PythonInterpreter object, then use it to
-         * execute some python code. In this case, we want to
-         * import the python module that we will coerce.
+         * 새 PythonInterpreter 개체를 생성한 다음, 파이썬
+         * 코드를 실행하는 데에 사용. 이 경우, 강제 변형할
+         * 파이썬 모듈을 수입한다.
          *
-         * Once the module is imported than we obtain a reference to
-         * it and assign the reference to a Java variable
+         * 일단 모듈이 수입되면 그에 대한 참조를 얻어서 자바
+         * 변수에 참조를 할당한다
          */
         
         public BuildingFactory() {
         }
         
         /**
-         * The create method is responsible for performing the actual
-         * coercion of the referenced python module into Java bytecode
+         * create 메소드는 참조되는 파이썬 모듈을 자바 바이트코드로
+         * 실질적인 강제 변형을 수행할 책임이 있다
          */
         
         public BuildingType create (String name, String location, String id) {
     }
 
 
-The third piece of code in the example above plays a most important
-role, since this is the object factory that will coerce our Jython
-code into a resulting Java class. In the constructor, a new
-instance of the PythonInterpreter is created. We then utilize the
-interpreter to obtain a reference to our Jython object and store it
-into our PyObject. Next, there is a static method named *create*
-that will be called in order to coerce our Jython object into Java
-and return the resulting class. It does so by performing a
-*__call__* on the PyObject wrapper itself, and as you can see
-we have the ability to pass parameters to it if we like. The
-parameters must also be wrapped by PyObjects. The coercion takes
-place when the *__tojava__* method is called on the PyObject
-wrapper. In order to make object implement our Java interface, we
-must pass the interface *EmployeeType.class* to the
-*__tojava__* call.
+위의 세번째 코드 조각은 가장 중요한 역할을 담당하는데, 이는 개체 팩토리가 우리의 자이썬 코드를 결과 자바 클래스로 강제 변형하기 때문이다.
+생성자 내에서 PythonInterpreter의 새 인스턴스가 만들어진다.
+그러면 우리의 자이썬 개체에 대한 참조를 얻기 위해 우리의 PyObject로 저장 인터프리터를 이용한다.
+다음으로는, *create*\ 라는 이름의 정적 메소드가 있다.
+우리의 자이썬 모듈을 자바로 강제 변형하기 위하여 호출되며, 결과 클래스를 반환한다.
+PyObject 래퍼 자체에 *__call__*\ 을 수행함으로써 그렇게 하며, 우리가 원한다면 인자를 전달하는 능력을 갖게 됨을 알 수 있다.
+매개 변수는 또한 PyObjects로 포장해야 한다.
+강제 변형은 PyObject 래퍼에 대하여 *__tojava__* 메소드가 호출될 때 일어난다.
+개체가 우리의 자바 인터페이스를 구현하도록 하기 위해서는, *__tojava__* 호출에 *EmployeeType.class* 인터페이스를 전달해야한다.
 
 **Main.java**
 ::
     
     import org.jython.book.util.BuildingFactory;
     import org.jython.book.interfaces.BuildingType;
-     
+    
     public class Main {
     
         private static void print(BuildingType building) {    
         }
     
         /**    
-         * Create three building objects by calling the create() method of
-         * the factory.
+         * 팩토리의 create() 메소드를 호출함으로써 세 개의 건물 개체를
+         * 생성.
          */
         
         public static void main(String[] args) {
     
     }
 
-The last bit of provided code, *Main.java*, shows how to make use
-of our factory. You can see that the factory takes care of all the
-heavy lifting and our implementation in *Main.java* is quite small.
-Simply call the *factory.create()* method to instantiate a new
-PyObject and coerce it into Java.
+제공된 코드의 마지막 부분인 *Main.java*\ 는 팩토리를 사용하는 방법을 보여준다.
+팩토리가 모든 무거운 일을 돌봐주기 때문에 *Main.java*\ 는 아주 작음을 볼 수 있다.
+단순히 *factory.create()* 메소드를 호출하여 새로운 PyObject의 인스턴스를 생성하고 그것을 자바로 강제 변형할 수 있다.
 
-This procedure for using the object factory design has the benefit
-of maintaining complete awareness of the Jython object from within
-Java code. In other words, creating a separate factory for each
-Jython object allows for the use of passing arguments into the
-constructor of the Jython object. Since the factory is being
-designed for a specific Jython object, we can code the
-*__call__* on the PyObject with specific arguments that will be
-passed into the new constructor of the coerced Jython object. Not
-only does this allow for passing arguments into the constructor,
-but also increases the potential for good documentation of the
-object since the Java developer will know exactly what the new
-constructor will look like. The procedures performed in this
-subsection are probably the most frequently used throughout the
-Jython community. In the next section, we'll take a look at the
-same technique applied to a generic object factory that can be used
-by any Jython object.
+개체 팩토리 디자인을 사용하는 이러한 절차에는, 자바 코드 내에서 자이썬 개체에 대한 완전한 인식을 유지할 수 있다는 이점이 있다.
+달리 말해, 각각의 자이썬 개체에 대한 개별적인 팩토리를 생성함으로 해서 자이썬 개체의 생성자로 인자를 전달하는 것이 가능하다.
+팩토리는 특정한 자이썬 개체를 위하여 디자인되었기 때문에, 우리는 PyObject에 대하여 강제 변형된 자이썬 개체의 새로운 생성자로 전달될 특정한 인자를 가지고 *__call__* 코드를 작성할 수 있다.
+이는 생성자로 인자를 전달할 뿐 아니라, 자바 개발자가 새로운 생성자에 대하여 정확히 알 수 있으므로 좋은 문서화에 대한 잠재적인 가능성도 높여준다
+이 하위 섹션에서 수행하는 절차는 아마도 자이썬 커뮤니티에서 가장 빈번하게 사용될 것이다.
+다음 섹션에서는, 어떠한 자이썬 개체에도 사용할 수 있는 제너릭 개체 팩토리에 동일한 기법을 적용하는 것을 살펴보도록 하겠다.
 
-Summary of One-to-One Object Factory
+일대일 개체 팩토리 요약
+~~~~~~~~~~~~~~~~~~~~~~~
+
+이 디자인 패턴의 핵심은 순서 원하는 자이썬 모듈을로드하기 위해 PythonInterpreter을 활용하여 팩토리 방식의 창조이다.
+팩토리 PythonInterpreter을 통해 모듈이 로드되면, 이 모듈의 PyObject 인스턴스를 만든다.
+마지막으로, 그 팩토리는 PyObject의 __tojava__ 메소드를 사용하여 PyObject를 자바 코드로 강제 변형한다.
+
+그러한 아이디어는 그다지 어려운 것이 아니며 상대적으로 직관적인 편이다.
+그러나, 자이썬 모듈 및 그에 상응하는 자바 인터페이스에 대한 참조를 전달하려고 하면 다른 구현이 등장하게 된다.
+자이썬 개체를 초기화하고 자바로 탈바꿈하는 일을 팩토리가 처리해준다는 점에 유의하는 것이 중요하다.
+결과 자바 개체에 대해 수행되는 모든 작업은 상응하는 자바 인터페이스에 대한 코드이다.
+우리가 인터페이스에 포함된 정의를 변경하지 않고도 원하는 경우 우리는 자이썬 코드 구현을 변경할 수 있기 때문에 이것은 훌륭한 디자인이다.
+자바 코드를 한번 컴파일할 수 있고 우리가 애플리케이션을 한방울 흘리지 않고 마음대로 자이썬 코드를 변경할 수 있다.
+
+느슨하게 결합된 개체 팩토리 사용하기
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The key to this design pattern is the creation of a factory method
-that utilizes PythonInterpreter in order to load the desired Jython
-module. Once the factory has loaded the module via
-PythonInterpreter, it creates a PyObject instance of the module.
-Lastly, the factory coerces the PyObject into Java code using the
-PyObject __tojava__ method.
+개체 팩토리 디자인을 구현하는 방법에는 위의 예제에 묘사된 것과 같은 일대일 전략만 있는 것은 아니다. 
+어떠한 자이썬 개체에나 활용할 수 있을만큼 충분히 일반적인 방법으로 팩토리를 디자인하는 것이 가능하다.
+이는 모든 자이썬 개체에 대하여 사용할 수 있는 단 하나의 싱글톤 팩토리를 필요로 하므로 상용구의 코딩을 줄일 수 있는 기법이다.
+그것은 또한 사용을 쉽게 해주는데, 개체 팩토리 로직을 개별 프로젝트로 나눈 뒤에 원하는 곳에 어디든 적용할 수 있도록 해주기 때문이다.
+예를 들어, 필자는 PlyJy(http://kenai.com/projects/plyjy)라는 프로젝트를 생성했는데, 이것은 기본적으로 자바 애플리케이션 내에서 사용되는 자이썬 개체 팩토리를 포함하며, 팩토리에 대하여 걱정하지 않고서도 자바에서 자이썬 개체를 생성할 수 있도록 하기 위한 것이다.
+좀 더 살펴보고 싶다면 누리집에서 Kenai를 내려받아서 느슨하게 결합된\ *loosely coupled* 개체 팩토리에 대하여 학습하기 바란다. 
+이 섹션에서는 그 프로젝트 배후의 디자인과 작동원리에 대하여 살펴보고자 한다.
 
-Overall, the idea is not very difficult to implement and relatively
-straightforward. However, the different implementations come into
-play when it comes to passing references for the Jython module and
-a corresponding Java interface. It is important to note that the
-factory takes care of instantiating the Jython object and
-translating it into Java. All work that is performed against the
-resulting Java object is coded against a corresponding Java
-interface. This is a great design because it allows us to change
-the Jython code implementation if we wish without altering the
-definition contained within the interface. The Java code can be
-compiled once and we can change the Jython code at will without
-breaking the application.
+그러면 위에서와 동일한 예제를 살펴보고 느슨하게 결합된 개체 팩토리 디자인을 적용해보도록 하자.
+이러한 기법은 자바 개발자로서는 팩토리로부터 개체를 생성하는 데에 좀 더 품이 들기는 하지만, 각각의 자이썬 개체에 대하여 개별적으로 팩토리를 생성하는 데에 쏟을 시간을 절약하도록 해주는 이점이 있는 것을 알게 될 것이다.
+느슨하게 결합된 팩토리는 PyObject에 대하여 제너릭한 *__call__*\ 을 하므로 개체에 인자를 전달하기 위하여 더 이상 생성자를 이용하지 않아도 되며, 따라서 자이썬 개체에 setter를 작성하고 이를 자바 인터페이스를 통하여 노출시킬 필요가 있다.
 
-Making Use of a Loosely Coupled Object Factory
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The object factory design does not have to be implemented using a
-one to one strategy such as that depicted in the example above. It
-is possible to design the factory in such a way that it is generic
-enough to be utilized for any Jython object. This technique allows
-for less boilerplate coding as you only require one Singleton
-factory that can be used for all Jython objects. It also allows for
-ease of use as you can separate the object factory logic into its
-own project and then apply it wherever you'd like. For instance,
-I've created a project named PlyJy
-(http://kenai.com/projects/plyjy) that basically contains a Jython
-object factory that can be used in any Java application in order to
-create Jython objects from Java without worrying about the factory.
-You can go to Kenai and download it now to begin learning about
-loosely coupled object factories. In this section we'll take a look
-at the design behind this project and how it works.
-
-Let's take a look at the same example from above and apply the
-loosely coupled object factory design. You will notice that this
-technique forces the Java developer to do a bit more work when
-creating the object from the factory, but it has the advantage of
-saving the time that is spent to create a separate factory for each
-Jython object. You can also see that now we need to code setters
-into our Jython object and expose them via the Java interface as we
-can no longer make use of the constructor for passing arguments
-into the object since the loosely coupled factory makes a generic
-*__call__* on the PyObject.
-
-*Listing 10-4. Using a Loosely Coupled Object Factory*
+*예제 10-4. 느슨하게 결합된 객체 팩토리 사용하기*
 
 **Building.py**
 ::
     # Building object that subclasses a Java interface
     
     class Building(BuildingType):
-   
+    
         def __init__(self):
             self.name = None
             self.address = None
             self.id = -1  
-
+        
         def getBuildingName(self):
             return self.name
-           
+        
         def setBuildingName(self, name):
             self.name = name;
-    
+        
         def getBuildingAddress(self):
             return self.address
-   
+        
         def setBuildingAddress(self, address)
             self.address = address
-   
+        
         def getBuildingId(self):
             return self.id
-    
+        
         def setBuildingId(self, id):
             self.id = id
 
-If we follow this paradigm then you can see that our Jython module
-must be coded a bit differently than it was in our one-to-one
-example. The main differences are in the initializer as it no
-longer takes any arguments, and we therefore have coded setter
-methods into our object. The rest of the concept still holds true
-in that we must implement a Java interface that will expose those
-methods we wish to invoke from within our Java application. In this
-case, we coded the *BuildingType.java* interface and included the
-necessary setter definitions so that we have a way to load our
-class with values.
+이러한 패러다임을 따르는 경우에는 자이썬 모듈을 일대일 예제와는 약간 다르게 작성하여야 한다.
+주된 차이점은 초기자가 더 이상 인자를 취하지 않는다는 것이며, 따라서 우리의 개체 내에 setter 모듈을 코딩하였다.
+그외에 자바 애플리케이션 내에서 호출하고자 하는 메소드를 노출하는 자바 인터페이스를 구현하여야 한다는 개념은 여전히 유효하다. 
+여기서는 *BuildingType.java* 인터페이스를 코딩할 때 필요로 하는 setter 정의를 포함시킴으로써 우리의 클래스를 값과 함께 적재하였다.
 
 **BuildingType.java**
 ::
-    
+   
    package org.jython.book.interfaces;
-    
+   
    /**
     * Java interface defining getters and setters
     */
    
    public interface BuildingType {
-    
+   
     public String getBuildingName();
     public String getBuildingAddress();
     public int getBuildingId();
    
    }
 
-Our next step is to code a loosely coupled object. If you take a
-look at the code in the *JythonObjectFactory.java* class you will
-see that it is a singleton; that is it can only be instantiated one
-time. The important method to look at is *createObject()* as it
-does all of the work.
+우리의 다음 단계는 느슨하게 결합된 개체를 코드하는 것이다.
+*JythonObjectFactory.java* 클래스의 코드를 한번 살펴보면 그것이 싱글톤-한번만 인스턴스화되는 것-임을 알 수 있을 것이다.
+*createObject()*\ 는 모든 일을 처리하는 중요한 메소드이므로 살펴보도록 하자.
 
 **JythonObjectFactory.java**
 ::
     import java.util.logging.Logger;
     import org.python.core.PyObject;
     import org.python.util.PythonInterpreter;
-     
+    
     /**
      * Object factory implementation that is defined
      * in a generic fashion.
      *
      */
-     
+    
     public class JythonObjectFactory {
         private static JythonObjectFactory instance = null;
         private static PyObject pyObject = null;
-         
+        
         protected JythonObjectFactory() {
         
         }
             if(instance == null){
                 instance = new JythonObjectFactory();
             }
-         
+        
             return instance;
         }
-         
+        
         /**
          * The createObject() method is responsible for the actual creation of the
          * Jython object into Java bytecode.
             // to obtain a reference.
             PythonInterpreter interpreter = new PythonInterpreter();
             interpreter.exec("from " + moduleName + " import " + moduleName);
-             
+            
             pyObject = interpreter.get(moduleName);
-             
+            
             try {
                 // Create a new object reference of the Jython module and
                 // store into PyObject.
     
     }
 
-As you can see from the code, the PythonInterpreter is responsible
-for obtaining a reference to the Jython object name that we pass as
-a String value into the method. Once the PythonInterpreter has
-obtained the object and stored it into a PyObject, its
-*__call__()* method is invoked without any parameters. This
-will retrieve an empty object that is then stored into another
-PyObject referenced by *newObj*. Lastly, our newly obtained object
-is coerced into Java code by calling the *__tojava__()* method
-which takes the fully qualified name of the Java interface we've
-implemented with our Jython object. The new Java object is then
-returned.
+코드에서 볼 수 있듯이, PythonInterpreter에는 우리가 문자열 값으로 메소드에 전달하는 자이썬 개체 이름에 대한 참조를 얻을 책임이 있다.
+PythonInterpreter가 일단 개체를 얻어서 PyObject에 저장하면, 그것의 *__call__()* 메소드가 아무 매개변수 없이 호출된다.
+이것은 *newObj*에 의해 참조된 다른 PyObject에 저장된 비어있는 개체를 retrive한다.끝으로, 새로 얻어진 개체는 우리가 자이썬 개체를 가지고 구현한 자바 인터페이스에 대한 fully qualified name을 취하는 *__tojava__()* 메소드 호출에 의하여, 자바 코드로 강제 변형된다.
+새로운 자바 개체가 반환된다.
 
 **Main.java**
 ::
     import java.util.logging.Logger;
     import org.jythonbook.interfaces.BuildingType;
     import org.jybhonbook.factory.JythonObjectFactory;
-     
+    
     public class Main {
-     
+    
         public static void main(String[] args) {
-         
+        
         // Obtain an instance of the object factory
         JythonObjectFactory factory = JythonObjectFactory.getInstance();
-         
+        
         // Call the createObject() method on the object factory by
         // passing the Java interface and the name of the Jython module
         // in String format. The returning object is casted to the the same
         building.setBuildingId(1);
         System.out.println(building.getBuildingId() + " " + building.getBuildingName() + " " +
             building.getBuildingAddress());
-         
+        
         }
     
     }
 
 
-Taking a look at the *Main.java* code, you can see that the factory
-is instantiated or referenced via the use of the
-*JythonObjectFactory.getInstance()*. Once we have an instance of
-the factory, the *createObject(**Interface, String)* is called
-passing the interface and a string representation of the module
-name we wish to use. The code must cast the coerced object using
-the interface as well. This example assumes that the object resides
-somewhere on your sys.path, otherwise you can use the
-*createObjectFromPath(**Interface, String)* that accepts the string
-representation for the path to the module we'd like to coerce. This
-is of course not a preferred technique since it will now include
-hard-coded paths, but it can be useful to apply this technique for
-testing purposes. For example if you've got two Jython modules
-coded and one of them contains a different object implementation
-for testing purposes, then this technique will allow you to point
-to the test module.
+*Main.java* 코드를 살펴보면, 팩토리는 *JythonObjectFactory.getInstance()*\ 를 통하여 초기화 또는 참조됨을 알 수 있다. 일단 팩토리의 인스턴스를 갖게 되면, *createObject(**Interface, String)*\ 가 호출되어 인터페이스에 사용하고자 하는 모듈 이름에 대한 문자열 표현을 전달한다.
+그 코드는 인터페이스를 사용할 뿐 아니라 반드시 강제 변형 개체를 형 변환\ *cast*\ 하여야 한다.
+이 예제는 개체가 sys.path의 어딘가에 존재하는 것으로 가정하며, 그렇지 않으면 강제 변형하고자 하는 모듈이 있는 경로를 나타내는 문자열을 받아들이는 *createObjectFromPath(Interface, String)*\ 을 사용할 수 있다.
+이는 하드 코딩된 경로를 포함하기 때문에 물론 선호되지 않는 기법이지만, 시험적으로 사용하기에는 유용할 수 있다.
+예를 들어 두 자이썬 모듈은 암호화된 있는데 만약 그 중 하나는 다음이 기술은 시험 모듈을 가리 키도록 수 있도록, 테스트 목적으로 다른 개체 구현을 포함하고 있다.
 
-More Efficient Version of Loosely Coupled Object Factory
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+느슨하게 결합된 개체 팩토리의 보다 효율적인 버전
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Another similar, yet, more refined implementation omits the use of
-PythonInterpreter and instead makes use of PySystemState. Why would
-we want another implementation that produces the same results?
-Well, there are a couple of reasons. The loosely coupled object
-factory design I described in the beginning of this section
-instantiates the PythonInterpreter and then makes calls against it.
-This can cause a decrease in performance, as it is quite expensive
-to use the interpreter. On the other hand, we can make use of
-PySystemState and save ourselves the trouble of incurring extra
-overhead making calls to the interpreter. Not only does the next
-example show how to utilize this technique, but it also shows how
-we can make calls upon the coerced object and pass arguments at the
-same time.
+비슷하지만 좀 더 세련된 구현은 PythonInterpreter를 생략하고, 그 대신 PySystemState를 사용하는 것이다.
+동일한 결과를 만들어내기 위하여 왜 다른 구현을 하여야 할까?
+그에 대하여 다음과 같은 몇 가지 이유를 들 수 있다.
+이 섹션의 시작 부분에서 설명하는 느슨하게 결합된 개체 팩토리 디자인은 PythonInterpreter에 대한 인스턴스화 이후에 그것을 호출한다.
+이는 인터프리터 입장에서는 비용이 많이 드므로, 성능 저하를 유발할 수 있다.
+반면에, 우리는 PySystemState을 활용할 수 있으며, 자신에게 여분의 오버헤드를 인터프리터를 호출하는 부담의 문제를 줄일 수 있다.
+다음의 예제는 이러한 기법을 어떻게 사용하는지를 보임과 함게, 강제 변형된 개체를 호출하는 동시에 인자를 전달하는 방법을 보인다
 
-*Listing 10-5. Use PySystemState to Code a Loosely Coupled Factory*
+*예제 10-5. 느슨하게 결합된 팩토리 코드 PySystemState 사용*
 
 **JythonObjectFactory.java**
 ::
 
    package org.jython.book.util;
-    
+   
    import org.python.core.Py;
    import org.python.core.PyObject;
    import org.python.core.PySystemState;
-    
+   
    /**
     * Jython Object Factory using PySystemState
     */
    public class JythonObjectFactory {
-    
+   
     private final Class interfaceType;
     private final PyObject klass;
     
-    // Constructor obtains a reference to the importer, module, and the class name
+    // 생성자는 importer, module, 그리고 class 이름에 대한 참조를 얻음
     public JythonObjectFactory(PySystemState state, Class interfaceType, String moduleName, String className) {
         this.interfaceType = interfaceType;
         PyObject importer = state.getBuiltins().__getitem__(Py.newString("__import__"));
         System.err.println("module=" + module + ",class=" + klass);
     }
     
-    // This constructor passes through to the other constructor
+    // 이 생성자는 다른 생성자에게 전달됨
     public JythonObjectFactory(Class interfaceType, String moduleName, String className) {
         this(new PySystemState(), interfaceType, moduleName, className);
     }
     
-    // All of the followng methods return
-    // a coerced Jython object based upon the pieces of information
-    // that were passed into the factory. The differences are
-    // between them are the number of arguments that can be passed
-    // in as arguents to the object.
+    // 다음의 모든 메소드는 팩토리로 전달된 정보의 조각들에 근거하여
+    // 강제 변형된 자이썬 개체를 반환한다. 그것들 간의 차이점은
+    // 개체에 대하여 전달 가능한 인자의 갯수이다.
     
     public Object createObject() {
         return klass.__call__().__tojava__(interfaceType);
     }
     
-     
+    
     public Object createObject(Object arg1) {
         return klass.__call__(Py.java2py(arg1)).__tojava__(interfaceType);
     }
 
 **Main.java**
 ::
-         
+    
     import org.jython.book.interfaces.BuildingType;
     import org.jython.book.util.JythonObjectFactory;
-     
+    
     public class Main{
-     
+    
         public static void main(String args[]) {
-         
+        
             JythonObjectFactory factory = new JythonObjectFactory(
                 BuildingType.class, "building", "Building");
-             
+            
             BuildingType building = (BuildingType) factory.createObject();
-             
+            
             building.setBuildingName("BUIDING-A");
             building.setBuildingAddress("100 MAIN ST.");
             building.setBuildingId(1);
-             
+            
             System.out.println(building.getBuildingId() + " " +
                 building.getBuildingName() + " " +
                 building.getBuildingAddress());
         }
-     
+    
     }
 
-As you can see from the code, there are quite a few differences
-from the object factory implementation shown previously. First, you
-can see that the instantiation of the object factory requires
-different arguments. In this case, we pass in the interface,
-module, and class name. Next, you can see that the PySystemState
-obtains a reference to the importer PyObject. The importer then
-makes a __call__ to the module we've requested. The requested
-module must be contained somewhere on the sys.path. Lastly, we
-obtain a reference to our class by calling the __getattr__
-method on the module. We can now use the returned class to perform
-the coercion of our Jython object into Java. As mentioned
-previously, you'll note that this particular implementation
-includes several createObject() variations allowing one to pass
-arguments to the module when it is being called. This, in effect,
-gives us the ability to pass arguments into the initializer of the
-Jython object.
+위의 코드에서 볼 수 있듯이, 앞서 보았던 개체 팩토리 구현과는 몇 가지 차이점이 있다.
+첫째, 개체 팩토리의 초기화에 필요한 인자가 다르다.
+여기서는 인터페이스, 모듈 및 클래스 이름을 전달한다.
+다음으로, PySystemState는 importer PyObject에 대한 참조를 얻는다.
+그러면 importer는 우리가 요청한 모듈에 대하여 __call__을 일으킨다.
+요청한 모듈은 sys.path 어딘가에 포함되어 있어야한다.
+끝으로, 우리는 모듈에 __getattr__ 메소드를 호출함으로서 클래스에 대한 참조를 얻는다.
 
-Which object factory is best? Your choice, depending upon the
-situation you're application is encountering. Bottom line is that
-there are several ways to perform the object factory design and
-they all allow seamless use of Jython objects from within Java
-code.
+이제 우리는 반환된 클래스를 사용하여 자이썬 개체를 자바로 강제 변형을 수행할 수 있다.
+앞서 언급한 바와 같이, 특정 구현은 호출될 때 모듈에 인자를 다양하게 전달할 수 있도록 여러 개의 createObject()를 포함한다.
+이것은 사실상, 우리에게 자이썬 개체의 초기화에 인수를 전달할 수있는 능력을 제공한다.
 
-Now that we have a coerced Jython object, we can go ahead and
-utilize the methods that have been defined in the Java interface.
-As you can see, the simple example above sets a few values and then
-prints out the object values. Hopefully you can see how easy it is
-to create a single object factory that we can be use for any Jython
-object rather than just one.
+어떤 팩토리를 사용하는 것이 최선인가?
+여러분의 애플리케이션이 처한 상황에 따라 선택할 부분이다.
+개체 팩토리를 디자인하는 데에는 여러 방법이 있으며, 어떠한 방법을 택하든 자바 코드 내에서 자이썬 개체를 원활하게 사용할 수 있다.
 
-Returning __doc__ Strings
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+이제 우리는 강제 변형된 자이썬 개체를 가지며, 자바 인터페이스에서 정의된 메소드를 활용할 수 있다.
+당신이 볼 수 있듯이, 간단한 예제는 위의 몇 가지 값을 설정 다음 개체 값을 출력한다.
+단일 개체 팩토리를 생성하여 어떠한 자이썬 개체를 위하여 사용할 수 있도록 하는 것이 얼마나 쉬운지 알게 되었기를 바란다.
 
-It is also very easy to obtain the *__doc__* string from any of
-your Jython classes by coding an accessor method on the object
-itself. We'll add some code to the building object that was used in
-the previous examples. It doesn't matter what type of factory you
-decide to work with, this trick will work with both.
+__doc__ 문자열 반환
+~~~~~~~~~~~~~~~~~~~
 
-*Listing 10-6. __doc__ Strings*
+그것은 또한 매우 개체 자체에 접근 방법을 코딩하여 자이썬 클래스의 어느 __doc__ * 문자열 *을 쉽게 구할 수 있다.
+우리는 이전의 예제에서 사용했던 건물 개체에 몇 가지 코드를 추가한다.
+두 가지 팩토리 중 어느 쪽을 택하더라도, 이러한 트릭은 유효할 것이다.
+
+*예제 10-6. __doc__ Strings*
 
 **Building.py**
 ::
 ::
     
     package org.jython.book.interfaces;
-     
+    
     public interface BuildingType {
     
         public String getBuildingName();
         public void setBuildingAddress(String address);
         public void setBuildingId(int id);
         public String getDoc();
-     
+    
     }
 
 
     import java.util.logging.Logger;
     import org.jython.book.interfaces.BuildingType;
     import org.plyjy.factory.JythonObjectFactory;
-     
+    
     public class Main {
-     
+    
         public static void main(String[] args) {
-         
+        
             JythonObjectFactory factory = JythonObjectFactory.getInstance();
             BuildingType building = (BuildingType) factory.createObject(
                 BuildingType.class, "Building");
             System.out.println(building.getBuildingId() + " " +
                 building.getBuildingName() + " " +
             building.getBuildingAddress());
-             
+            
             // It is easy to print out the documentation for our Jython object
             System.out.println(building.getDoc());
-         
+        
         }
     }
 
     Class to hold building objects
 
 
-Applying the Design to Different Object Types
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+다른 개체 형식으로 디자인을 적용
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-This design will work with all object types, not just plain old
-Jython objects. In the following example, the Jython module is a
-class containing a simple calculator method. The factory coercion
-works the same way, and the result is a Jython class that is
-converted into Java.
+이 디자인은 플레인한 구식 자이썬 개체 뿐만 아니라 모든 유형에서 작동한다.
+다음 예제에서, 자이썬 모듈은 간단한 계산기 방법을 포함하는 클래스이다.
+팩토리 강제 변형은 동일한 방식으로 작동하며, 그 결과로는 자바로 변환된 자이썬 클래스를 얻는다.
 
-*Listing 10-7. Different Method Types*
+*예제 10-7. 다른 메소드 유형*
 
 **CostCalculator.py**
 ::
     
     class CostCalculator(CostCalculatorType, object):
         ''' Cost Calculator Utility '''
-     
+    
         def __init__(self):
             print 'Initializing'
             pass
 ::
     
     package org.jython.book.interfaces;
-     
+    
     public interface CostCalculatorType {
-     
+    
         public double calculateCost(double salePrice, double tax);
-     
+    
     }
 
 
     import java.util.logging.Logger;
     import org.jython.book.interfaces.CostCalculatorType;
     import org.plyjy.factory.JythonObjectFactory;
-     
+    
     public class Main {
-     
+    
         public static void main(String[] args) {
-         
+        
             // Create factory and coerce Jython calculator object
             JythonObjectFactory factory = JythonObjectFactory.getInstance();
             CostCalculatorType costCalc = (CostCalculatorType)
     
     Initializing
     27.7772
-.. sidebar:: A Bit of History
-    Prior to Jython 2.5, the standard distribution of Jython included a
-    utility known as jythonc. Its main purpose was to provide the
-    ability to convert Python modules into Java classes so that Java
-    applications could seamlessly make use of Python code, albeit in a
-    roundabout fashion. jythonc actually compiles the Jython code down
-    into Java .class files and then the classes are utilized within the
-    Java application. This utility could also be used to freeze code
-    modules, create jar files, and to perform other tasks depending
-    upon which options were used. This technique is no longer the
-    recommended approach for utilizing Jython within Java applications.
-    As a matter of fact, jythonc is no longer packaged with the Jython
-    distribution beginning with the 2.5 release.
+.. sidebar:: 자이썬 2.5 이전에는, 자이썬의 표준 배포본에는 jythonc라는 유틸리티가 포함되어 있었다.
+    그것의 주된 목적은 파이썬 모듈을 자바 클래스로 변환하여 자바 애플리케이션이 자연스럽게 파이썬 코드를 사용하도록 하는 것이었다.
+    jythonc는 자이썬 코드를 자바 .class 파일로 컴파일한 다음 그 클래스들이 자바 애플리케이션 내에서 사용되는, roundabout 스타일로 albeit하였다.
+    이 유틸리티는 또한, 코드 모듈을 동결하는 JAR 파일을 만들고, 옵션이 사용된 어떤에 따라 다른 작업을 수행하는 데 사용될 수 있다.
+    자바 애플리케이션 내에서 자이썬을 활용하기 위한 접근으로서 이러한 기법은 더 이상 권장하지 않는다.
+    사실, jythonc는 자이썬 2.5 이상의 배포본에는 포함되지 않는다.
     
-    In order for jythonc to take a Jython class and turn it into a
-    corresponding Java class, it had to adhere to a few standards.
-    First, the Jython class had to subclass a Java object, either a
-    class or interface. It also had to do one of the following:
-    override a Java method, implement a Java method, or create a new
-    method using a signature.
+    jythonc는 자이썬 클래스를 가지고 그것과 연동하는 자바 클래스를 만들기 위해서, 몇 가지 기준을 고수했다.
+    첫번째로, 자이썬 클래스는 클래스나 인터페이스 중 한 가지의 자바 개체를 서브클래스하였다.
+    또한 다음 중 하나를 해야 했다.
+    자바 메소드를 오버라이드하거나, 자바 메소드를 구현하거나, 서명을 사용하여 새로운 메소드를 생성하여야 했다.
     
-    While this method worked well and did what it was meant to do, it
-    caused a separation between the Jython code and the Java code. The
-    step of using jythonc to compile Jython into Java is clean, yet, it
-    creates a rift in the development process. Code should work
-    seamlessly without the need for separate compilation procedure. One
-    should have the ability to utilize Jython classes and modules from
-    within a Java application by reference only, and without a special
-    compiler in between. There have been some significant advances in
-    this area, and many of the newer techniques have been discussed in
-    this chapter.
+    이러한 방법은 의도대로 잘 작동하기는 했지만, 자이썬 코드와 자바 코드의 괴리를 일으켰다.
+    자이썬을 자바로 컴파일하기 위해 jythonc를 사용하는 단계는 깔끔했지만, 개발 과정에 rift를 가져왔다.
+    코드는 별도의 컴파일 절차가 필요없이 원활하게 작동하여야 한다.
+    특별한 컴파일러가 없이, 자이썬 클래스와 모듈에 대한 참조만으로 그것들을 자바 애플리케이션에서 활용할 수 있어야 하는 것이다.
+    이러한 부분에서 많은 진전이 있었고, 새로운 기법이 이번 장에서 논의되었다.
 
 
 
 JSR-223
 -------
 
-With the release of Java SE 6 came a new advantage for dynamic
-languages on the JVM. JSR-223 enables dynamic languages to be
-callable via Java in a seamless manner. Although this method of
-accessing Jython code is not quite as flexible as using an object
-factory, it is quite useful for running short Jython scripts from
-within Java code. The scripting project
-(https://scripting.dev.java.net/) contains many engines that can be
-used to run different languages within Java. In order to run the
-Jython engine, you must obtain jython-engine.jar from the scripting
-project and place it into your classpath. You must also place
-jython.jar in the classpath, and it does not yet function with
-Jython 2.5 so Jython 2.5.1 must be used.
+Java SE 6에 들어서 JVM 상의 동적 언어에 대한 지원이 추가되었다.JSR-223에서는 자바를 통하여 동적 언어를 매끄럽게 호출할 수 있도록 해준다.
+자이썬 코드에 액세스하는 이 방법은 개체 팩토리를 사용하는 것만큼 유연하지는 않지만, 자바 코드 내에서 짧은 자이썬 스크립트를 실행하는 데 꽤 유용하다.
+스크립팅 프로젝트(https://scripting.dev.java.net/)는 자바 내에서 다른 언어를 실행하는 데 사용할 수 있는 여러 엔진을 포함하고 있다.
+자이썬 엔진을 실행하기 위해서는, 스크립팅 프로젝트에서 jython-engine.jar를 얻어서 classpath에 갖다놓아야 한다.
+또한 classpath에 jython.jar를 두어야하며, 이는 자이썬 2.5에서 작동하지 않으므로 자이썬 2.5.1을 사용하여야 한다.
 
-Below is a small example showing the utilization of the scripting
-engine.
+아래는 스크립팅 엔진의 활용을 보여주는 작은 예이다.
 
-*Listing 10-8. Using JSR-223*
+*예제 10-8. JSR-223 사용*
 ::
     
     import javax.script.ScriptEngine;
     import javax.script.ScriptEngineManager;
     import javax.script.ScriptException;
-     
+    
     public class Main {
-     
+    
         /**
          * @param args the command line arguments
          */
         public static void main(String[] args) throws ScriptException {
             ScriptEngine engine = new ScriptEngineManager().getEngineByName("python");
-             
+            
             // Using the eval() method on the engine causes a direct
             // interpretataion and execution of the code string passed into it
             engine.eval("import sys");
             engine.eval("print sys");
-             
+            
             // Using the put() method allows one to place values into
             // specified variables within the engine
             engine.put("a", "42");
-             
+            
             // As you can see, once the variable has been set with
             // a value by using the put() method, we an issue eval statements
             // to use it.
             engine.eval("print a");
             engine.eval("x = 2 + 2");
-             
+            
             // Using the get() method allows one to obtain the value
             // of a specified variable from the engine instance
             Object x = engine.get("x");
             System.out.println("x: " + x);
         }
-     
+    
     }
 
-Next, we see the result of running the application. The first two
-lines are automatically generated when the Jython interpreter is
-initiated; they display the JAR filescontained within the
-CLASSPATH. Following those lines, we see the actual program
-output.
+애플리케이션의 실행 결과를 확인해보자.
+처음의 두 행은 자이썬 인터프리터가 시작될 때 자동으로 생성되며, CLASSPATH에 포함된 JAR 파일들을 표시한다.그 뒤에는 실제 프로그램의 출력이 뒤따른다.
 
-**Result**
+**결과**
 ::
     
     *sys-package-mgr*: processing new jar,'/jsr223-engines/jython/build/jython-engine.jar'
     x: 4
 
 
-Utilizing PythonInterpreter
----------------------------
+PythonInterpreter 활용
+----------------------
 
-A similar technique to JSR-223 for embedding Jython is making use
-of the PythonInterpreter directly. This style of embedding code is
-very similar to making use of a scripting engine, but it has the
-advantage of working with Jython 2.5. Another advantage is that the
-PythonInterpreter enables you to make use of PyObjects directly. In
-order to make use of the PythonInterpreter technique, you only need
-to have jython.jar in your classpath; there is no need to have an
-extra engine involved.
+자이썬을 임베딩하는 데에 사용되는 JSR-223과 유사한 기법은 PythonInterpreter를 직접적으로 사용하는 것이다.
+코드를 임베딩하는 스타일은 스크립팅 엔진을 사용하는 것과 매우 유사하지만, 자이썬 2.5를 사용할 수 있다는 장점이 있다. PythonInterpreter의 또 다른 장점으로는 PyObjects를 직접적으로 사용할 수 있게 된다는 것을 들 수 있다.
+PythonInterpreter 기술을 활용하기 위해서는, classpath에 jython.jar가 필요하며, 그밖의 엔진은 필요하지 않다.
 
-**Listing 10-9. Using PythonInterpreter**
+**예제 10-9. PythonInterpreter 사용**
 ::
     
     import org.python.core.PyException;
     import org.python.core.PyInteger;
     import org.python.core.PyObject;
     import org.python.util.PythonInterpreter;
-     
+    
     public class Main {
-     
+    
         /**
         * @param args the command line arguments
         */
         public static void main(String[] args) throws PyException {
-         
+        
             // Create an instance of the PythonInterpreter
             PythonInterpreter interp = new PythonInterpreter();
-             
+            
             // The exec() method executes strings of code
             interp.exec("import sys");
             interp.exec("print sys");
-             
+            
             // Set variable values within the PythonInterpreter instance
             interp.set("a", new PyInteger(42));
             interp.exec("print a");
             interp.exec("x = 2+2");
-             
+            
             // Obtain the value of an object from the PythonInterpreter and store it
             // into a PyObject.
             PyObject x = interp.get("x");
             System.out.println("x: " + x);
         }
-     
+    
     }
 
-In the class above, we make use of the PythonInterpreter to execute
-Python code within the Java class. First, we create an instance of
-the PythonInterpreter object. Next, we make exec() calls against it
-to execute strings of code passed into it. Next we use the set()
-method in order to set variables within the interpreter instance.
-Lastly, we obtain a copy of the object that is stored in the
-variable x within the interpreter. We must store that object as a
-PyObject in our Java code.
+위의 클래스에서, 우리는 자바 클래스 내에서 파이썬 코드를 실행 PythonInterpreter을 사용한다.
+첫째, 우리는 PythonInterpreter 개체의 인스턴스를 만들 수 있다.
+다음으로, 그것에 대하여 exec() 호출을 함으로써, 그것에 전달되는 코드 문자열을 실행하도록 한다.
+다음으로는 set() 메소드를 사용하여 인터프리터 인스턴스 내의 변수를 설정한다.
+끝으로, 인터프리터 내의 변수 x에 저장된 개체의 사본을 얻는다.
+우리는 우리의 자바 코드에 PyObject로서 그 개체를 저장해야 한다.
 
-**Results**
+**결과**
 ::
     
     <module 'sys' (built-in)>
     42
     x: 4
 
-The following is a list of methods available for use within a
-PythonInterpreter object along with a description of
-functionality.
+표 10-2에 PythonInterpreter 개체 내에서 사용 가능한 메소드와 그에 대한 설명을 나열하였다.
 
-**Table 10-2.**PythonInterpreter Methods**
+** 10-2. PythonInterpreter 메소드**
 
 ======================================= =======================================================================================================================
-Method                             	Description
+메소드                                  설명
 ======================================= =======================================================================================================================
-setIn(PyObject)                         Set the Python object to use for the standard input stream
-setIn(java.io.Reader)    	        Set a java.io.Reader to use for the standard input stream
-setIn(java.io.InputStream)              Set a java.io.InputStream to use for the standard input stream
-setOut(PyObject)                        Set the Python object to use for the standard output stream
-setOut(java.io.Writer)                  Set the java.io.Writer to use for the standard output stream
-setOut(java,io.OutputStream)            Set the java.io.OutputStream to use for the standard output stream
-setErr(PyObject)                        Set a Python error object to use for the standard error stream
-setErr(java.io.Writer	                Set a java.io.Writer to use for the standard error stream
-setErr(java.io.OutputStream)            Set a java.io.OutputStream to use for the standard error stream
-eval(String)                            Evaluate a string as Python source and return the result
-eval(PyObject)	                        Evaluate a Python code object and return the result
-exec(String)                            Execute a Python source string in the local namespace
-exec(PyObject)                          Execute a Python code object in the local namespace
-execfile(String filename)               Execute a file of Python source in the local namespace
-execfile(java.io.InputStream)	        Execute an input stream of Python source in the local namespace
-compile(String)                         Compile a Python source string as  an expression or module
-compile(script, filename)	        Compile a script of Python source as an expression or module
-set(String name, Object value)          Set a variable of Object type in the local namespace
-set(String name, PyObject value)	Set a variable of PyObject type in the local namespace
-get(String)	                        Get the value of a variable in the local namespace
-get(String name, Class<T> javaclass     Get the value of a variable in the local namespace. The value will be returned as an instance of the given Java class.
+setIn(PyObject)                         표준 입력 흐름을 사용하기 위한 파이썬 개체를 설정
+setIn(java.io.Reader)                   표준 입력 흐름을 사용하기 위한 java.io.Reader를 설정
+setIn(java.io.InputStream)              표준 입력 흐름을 사용하기 위한 java.io.InputStream을 설정
+setOut(PyObject)                        표준 출력 흐름을 위한 파이썬 개체를 설정
+setOut(java.io.Writer)                  표준 출력 흐름을 위한 java.io.Writer를 설정
+setOut(java,io.OutputStream)            표준 출력 흐름을 위한 java.io.OutputStream을 설정 
+setErr(PyObject)                        표준 오류 흐름을 위한 파이썬 오류 개체를 설정
+setErr(java.io.Writer)                  표준 오류 흐름을 위한 java.io.Writer를 설정
+setErr(java.io.OutputStream)            표준 오류 흐름을 위한 java.io.OutputStream을 설정
+eval(String)                            문자열을 파이썬 소스로서 평가하여 그 결과를 반환
+eval(PyObject)                          파이썬 코드 개체를 평가하고 그 결과를 반환
+exec(String)                            로컬 이름공간에서 파이썬 소스 문자열을 실행
+exec(PyObject)                          로컬 이름공간에서 파이썬 코드 개체를 실행
+execfile(String filename)               로컬 이름공간에서 파이썬 소스 파일을 실행
+execfile(java.io.InputStream)           로컬 이름공간에서 파이썬 소스의 입력 흐름을 실행
+compile(String)                         파이썬 소스 문자열을 표현식 또는 모듈로서 컴파일
+compile(script, filename)               파이썬 소스 스크립트를 표현식 또는 모듈로서 컴파일
+set(String name, Object value)          로컬 이름공간에서 개체 유형의 변수를 설정
+set(String name, PyObject value)        로컬 이름공간에서 PyObject 유형의 변수를 설정
+get(String)                             로컬 이름공간에서 변수의 값을 얻음
+get(String name, Class javaclass)       로컬 이름공간에서 변수의 값을 얻음. 얻은 값은 주어진 자바 클래스의 인스턴스로 반환됨.
 ======================================= =======================================================================================================================
 
 
-Summary
-=======
+요약
+====
 
-Integrating Jython and Java is really at the heart of the Jython
-language. Using Java within Jython works just as we as adding other
-Jython modules; both integrate seamlessly. What makes this nice is
-that now we can use the full set of libraries and APIs available to
-Java from our Jython applications. Having the ability of using Java
-within Jython also provides the advantage of writing Java code in
-the Python syntax.
+자이썬과 자바의 통합이야말로 자이썬 언어의 핵심이다.
+자이썬 내에서 자바를 사용하는 것은 마치 다른 자이썬 모듈을 추가하는 것과 같으며, 이음매 없이 매끈하게 통합이 된다.
+이를 통하여 자바의 모든 라이브러리 및 API를 자이썬 애플리케이션에서 사용할 수 있게 되니 더할 나위 없이 훌륭하다.
+자이썬 내에서 자바를 사용할 수 있음으로 해서 또한 파이썬의 문법으로 자바 코드를 작성할 수 있는 이점이 있다.
 
-Utilizing design patterns such as the Jython object factory, we can
-also harness our Jython code from within Java applications.
-Although *jythonc* is no longer part of the Jython distribution, we
-can still effectively use Jython from within Java. There are object
-factory examples available, as well as projects such as PlyJy
-(http://kenai.com/projects/plyjy) that give the ability to use
-object factories by simply including a JAR in your Java
-application.
+자이썬 개체 팩토리와 같은 디자인 패턴을 활용하여, 우리는 또한 자바 애플리케이션 내에서 우리의 자이썬 코드를 활용할 수 있다.
+*jythonc*\ 는 더 이상 자이썬의 배포판에 포함되지 않지만, 우리가 아직 효과적으로 자바 내에서 자이썬을 사용할 수 있다.
+간단하게 자바 애플리케이션에서 JAR를 포함하여 개체 팩토리을 사용하는 능력을 주는 PlyJy(http://kenai.com/projects/plyjy)와 같은 개체 팩토리 예제를 사용할뿐만 아니라, 프로젝트가 있다.
 
-We learned that there are more ways to use Jython from within Java
-as well. The Java language added scripting language support with
-JSR-223 with the release of Java 6. Using a jython engine, we can
-make use of the JSR-223 dialect to sprinkle Jython code into our
-Java applications. Similarly, the PythonInterpreter can be used
-from within Java code to invoke Jython. Also keep an eye on
-projects such as Clamp
-(http://github.com/groves/clamp/tree/master): the Clamp project has
-the goal to make use of annotations in order to create Java classes
-from Jython classes. It will be exciting to see where this project
-goes, and it will be documented once the project has been
-completed.
+우리는 또한 자바 내부에서 자이썬을 사용하는 더 많은 방법이 있음을 배웠다.
+자바 언어에는 자바 6의 출시와 함께 JSR-223을 통한 스크립팅 언어에 대한 지원이 추가되었다. 자이썬 엔진을 사용하여, 자이썬 코드를 우리의 자바 애플리케이션에 뿌리기 위하여 JSR-223 방언을 활용할 수 있다. 
+마찬가지로, PythonInterpreter는 자바 코드 내에서 자이썬을 호출하는 데에 사용할 수 있다.
+또한 클램프(http://github.com/groves/clamp/tree/master)와 같은 프로젝트를 눈여겨보도록 하자. 클램프 프로젝트는 자이썬 클래스에서 자바 클래스를 생성하기 위해서 어노테이션을 사용하는 것을 목표를 하고 있다.
+이 프로젝트의 진행을 지켜보는 것은 흥분되는 일이 될 것이며, 프로젝트가 완료되면 문서화가 이루어질 것이다.
 
-In the next chapter, you will see how we can use Jython from within
-integrated development environments. Specifically, we will take a
-look at developing Jython with Eclipse and Netbeans. Utilizing an
-IDE can greatly increase developer productivity, and also assist in
-subtleties such as adding modules and JAR files to the classpath.
-
+다음 장에서는, 통합된 개발 환경 내에서 자이썬을 사용하는 방법을 살펴보려고 한다.
+특히, 우리는 이클립스와 넷빈을 사용한 자이썬 개발을 살펴볼 것이다.
+IDE는 쓰기에 따라 개발자의 생산성을 매우 높여주며, 모듈 및 JAR 파일을 classpath에 추가하는 등의 일을 편리하게 해준다.