Commits

Yong Choi committed 44b446c

Translate ch 13

  • Participants
  • Parent commits 016cc98

Comments (0)

Files changed (1)

SimpleWebApps.rst

 
 
 
-Quick and simple, the servlet takes the request and obtains value
-contained within the parameter *p*. It then assigns that value to a
-variable named *addtext*. This variable is then assigned to an
-attribute in the request named *page_text* and forwarded back to
-the *testJython.jsp* page. The code could just as easily have
-forwarded to a different JSP, which is how we’d go about creating a
-more in-depth application.
+빠르고 단순하게, 서블릿은 요청을 받아서 매개변수 *p* 내에 포함된 값을 얻는다. 그런 다음 그 값을 *addtext*\ 라는 이름의 변수에 할당한다. 그러면 이 변수는 *page_text*\ 라는 이름의 어트리뷰터에 할당하고 *testJython.jsp* 페이지로 역으로 전달한다. 이 코드는 깊이 있는 애플리케이션을 만들고자하는 경우에는 다른 JSP로 쉽게 전달할 수 있다.
 
-The second form in our JSP takes two values and returns the
-resulting sum to the page. If someone were to enter text instead of
-numerical values into the text boxes then an error message would be
-displayed in place of the sum. While very simplistic, this servlet
-demonstrates that any business logic can be coded in the servlet,
-including database calls, and so on. See Listing 13-7.
+JSP의 두 번째 양식은 두 값을 취하여 합을 페이지로 반환한다. 누군가가 텍스트 상자에 숫자 값이 아닌 텍스트를 입력하였다면 합 대신에 오류 메시지를 표시한다. 매우 단순하기는 하지만, 이 서블릿은 데이터베이스 호출 등을 포함하는 어떠한 업무로직이라도 코딩할 수 있음을 보여준다. 예제 13-7을 보라.
 
-*Listing 13-7. Jython Servlet Business Logic*
+*예제 13-7. 자이썬 서블릿 업무 로직*
 ::
     
     #######################################################################
 
 코드를 내장시켜주는 스크립틀릿이라고 하는 다양한 템플릿 태그를 사용하여 자바 서버 페이지에 코드를 포함시키는 것도 가능하다. 그러한 경우에, 빈 스크립팅 프레임워크(http://jakarta.apache.org/bsf/)와 같은 특수한 프레임워크를 사용하지 않는 한 JSP에는 반드시 자바 코드를 포함하여야 한다. 자바 서블릿 페이지에 대한 더 자세한 내용은 선 마이크로 시스템즈의 JSP 문서(http://java.sun.com/products/jsp/docs.html)나 Apress의 *Beginning JSP, JSF and Tomcat Web Development: From Novice to Professional*\ 와 같은 책을 참고하기 바란다.
 
-Applets and Java Web Start
-==========================
+애플릿과 자바 웹 스타트
+=======================
 
-At the time of this writing, applets in Jython 2.5.0 are not yet an
-available option. This is because applets must be statically
-compiled and available for embedding within a webpage using the
-*<applet>* or *<object>* tag. The static compiler known as
-*jythonc***has been removed in Jython 2.5.0 in order to make way
-for better techniques. Jythonc was good for performing certain
-tasks, such as static compilation of Jython applets, but it created
-a disconnect in the development lifecycle as it was a separate
-compilation step that should not be necessary in order to perform
-simple tasks such as Jython and Java integration. In a future
-release of Jython, namely 2.5.1 or another release in the near
-future, a better way to perform static compilation for applets will
-be included.
+글을 쓰고 있는 현재, 자이썬 2.5.0에서는 애플릿을 사용할 수 없다. 그 이유는 애플릿은 정적으로 컴파일되어야하며 웹 페이지에 포함하려면 *<applet>* 또는 *<object>* 태그를 사용하여야 하기 때문이다. *jythonc*\ 라는 정적 컴파일러는 더 나은 기술의 구현을 위해 자이썬 2.5.0에서 제거되었다.
+for better techniques. Jythonc는 자이썬 애플릿을 정적으로 컴파일하는 것과 같은 특정 작업을 수행하기에는 좋았지만, 자이썬과 자바의 통합과 같은 단순한 작업을 수행하기에는 불필요한 개별적인 컴파일 단계였기 때문에 개발 주기의 단절을 가져왔다. 머지 않은 미래의 자이썬 릴리스, 즉 2.5.1 또는 그 이상에는 애플릿을 위한 정적 컴파일을 수행하는 더 나은 방법이 포함될 것이다.
 
-For now, in order to develop Jython applets you will need to use a
-previous distribution including *jythonc* and then associate them
-to the webpage with the *<applet>* or *<object>* tag. In Jython,
-applets are coded in much the same fashion as a standard Java
-applet. However, the resulting lines of code are significantly
-smaller in Jython because of its sophisticated syntax. GUI
-development in general with Jython is a big productivity boost
-compared to developing a Java Swing application for much the same
-reason. This is why coding applets in Jython is a viable solution
-and one that should not be overlooked.
+현재로서는, 자이썬 애플릿을 개발하기 위해서는 *jythonc*\ 를 포함하는 이전의 배포본을 사용하여 웹페이지에 *<applet>* 또는 *<object>* 태그를 사용하여 연관시켜야 한다. 자이썬에서는, 표준 자바 애플릿과 상당히 비슷한 방식으로 애플릿을 작성한다. 하지만, 결과적인 행 수는 정교한 구문을 가진 자이썬 쪽이 훨씬 적다. 그와 같은 이유로, 일반적으로 자이썬으로 GUI를 개발하는 것이 자바 스윙 애플리케이션을 개발하는 것에 비하여 생산성이 크게 높다. 이것이 바로 애플릿을 자이썬으로 코딩하는 것이 좋은 해결책이며 그냥 지나쳐서는 안되는 이유이다.
 
-Another option for distributing GUI-based applications on the web
-is to make use of the Java Web Start technology. The only
-disadvantage of creating a web start application is that it cannot
-be embedded directly into any web page. A web start application
-downloads content to the client’s desktop and then runs on the
-client’s local JVM. Development of a Java Web Start application is
-no different than development of a standalone desktop application.
-The user interface can be coded using Jython and the Java Swing
-API, much like the coding for an applet user interface. Once you’re
-ready to deploy a web start application then you need to create a
-Java Network Launching Protocol (JNLP) file that is used for
-deployment and bundle it with the application. After that has been
-done, you need to copy the bundle to a web server and create a web
-page that can be used to launch the application.
+GUI 기반의 에플리케이션을 웹에 분배하는 또 다른 방법으로는 자바 웹 스타트 기술의 사용을 들 수 있다. 웹 스타트 애플리케이션의 유일한 단점은 웹 페이지에 직접적으로 포함시킬 수 없다는 점이다. 웹 스타트 애플리케이션은 컨텐트를 클라이언트의 데스크톱에 다운로드한 다음 클라이언트의 지역 JVM에서 수행한다. 자바 웹 스타트 애플리케이션의 개발은 독립실행 데스크톱 애플리케이션의 개발과 다르지 않다.
+사용자 인터페이스는 애플릿 사용자 인터페이스를 코딩하는 것과 마찬가지로 자이썬과 자바 스윙으로 코딩할 수 있다. 웹 스타트 애플리케이션을 배포할 준비가 되면, 배포에 사용되는 자바 네트워크 론칭 프로토콜 (JNLP) 파일을 생성하여 애플리케이션과 함께 제공할 필요가 있다. 그러한 일을 마친 후에, 웹 서버의 묶음을 복사하고 애플리케이션을 띄우는 데 사용할 웹 페이지를 생성한다.
 
-In this section we will develop a small web start application to
-demonstrate how it can be done using the object factory design
-pattern and also using pure Jython along with the standalone Jython
-JAR file for distribution. Note that there are probably other ways
-to achieve the same result and that these are just a couple of
-possible implementations for such an application.
+이 섹션에서는 작은 웹 스타트 애플리케이션의 개발을 통하여, 개체 팩토리 디자인 패턴 및 독립실행 자이썬 JAR 파일과 함께 순수 자이썬을 사용하여 배포하는 예를 살펴볼 것이다. 그러한 목적을 달성하는 데에는 다른 방법도 있으며, 여기서는 다만 두 가지의 가능한 구현을 예시하였음을 주지하기 바란다.
 
-Coding a Simple GUI-Based Web Application
------------------------------------------
+단순한 GUI 기반 웹 애플리케이션의 작성
+--------------------------------------
 
-The web start application that we will develop in this
-demonstration is very simple, but they can be as advanced as you’d
-like in the end. The purpose of this section is not to show you how
-to develop a web-based GUI application, but rather, the process of
-developing such an application. You can actually take any of the
-Swing-based applications that were discussed in the GUI chapter and
-deploy them using web start technology quite easily. As stated in
-the previous section, there are many different ways to deploy a
-Jython web start application. We prefer to make use of the object
-factory design pattern to create simple Jython Swing applications.
-However, it can also be done using all .py files and then
-distributed using the Jython stand-alone JAR file. We will discuss
-each of those techniques in this section. We find that if you are
-mixing Java and Jython code then the object factory pattern works
-best. The JAR method may work best for you if developing a strictly
-Jython application.
+이 예제에서 개발하는 웹 스타트 애플리케이션은 매우 단순하지만, 여러분이 원한다면 더욱 발전시킬 수 있다. 이 섹션의 목적은 웹 기반의 GUI 애플리케이션을 어떻게 개발하는지를 보이는 것보다는, 그러한 애플리케이션을 개발하는 과정을 보이는 데에 있다. 실제로 GUI 장에서 논의하였던 어떠한 스윙 기반 애플리케이션이나 취하여 웹 스타트 기법을 사용하여 아주 쉽게 배포할 수 있다. 이전 섹션에서 기술한 바와 같이, 자이썬 웹 스타트 애플리케이션을 배포하는 데에는 여러 다른 방법이 있다. 우리는 간단한 자이썬 스윙 애플리케이션을 생성하기 위하여 개체 팩토리 디자인 패턴을 사용하는 쪽을 선호한다.
+하지만, 모든 .py 파일을 사용하고 자이썬 독립실행 JAR 파일을 사용하여 배포하는 것 또한 가능하다. 이 섹션에서 그러한 기법들 각각에 대하여 논의할 것이다. 자바와 자이썬 코드를 혼합할 것이라면 개체 팩토리 패턴이 최선이라는 점을 알아냈다. JAR 방법은 엄격한 자이썬 애플리케이션을 개발할 때에 가장 잘 작동할 것이다.
 
-Object Factory Application Design
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+개체 팩토리 애플리케이션 디자인
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The application we’ll be developing in this section is a simple GUI
-that takes a line of text and redisplays it in JTextArea. We used
-Netbeans 6.7 to develop the application, so some of this section
-may reference particular features that are available in that IDE.
-To get started with creating an object factory web start
-application, we first need to create a project. We created a new
-Java application in Netbeans named *JythonSwingApp* and then added
-*jython.jar* and *plyjy.jar* to the classpath.
+이 섹션에서 개발할 애플리케이션은 간단한 GUI로서 한 줄의 텍스트를 받아서 그것을 다시 JTextArea에 출력한다. 애플리케이션의 개발에는 넷빈스 6.7을 사용하며, 이 섹션의 일부는 그 IDE에서 제공하는 특정 기능을 참조할 수 있다.
+개체 팩토리 웹 스타트 애플리케이션을 생성하기 시작하려면, 우선 프로젝트를 생성할 필요가 있다. 넷빈스에서 새로운 *JythonSwingApp*\ 이라는 이름의 자바 애플리케이션을 생성하고 *jython.jar*\ 와 *plyjy.jar*\ 를 classpath에 추가한다.
 
-First, create the *Main.java* class which will really be the driver
-for the application. The goal for Main.java is to use the Jython
-object factory pattern to coerce a Jython-based Swing application
-into Java. This class will be the starting point for the
-application and then the Jython code will perform all of the work
-under the covers. Using this pattern, we also need a Java interface
-that can be implemented via the Jython code, so this example also
-uses a very simple interface that defines a *start()* method which
-will be used to make our GUI visible. Lastly, the Jython class
-named below is the code for our *Main.java* driver and the Java
-interface. The directory structure of this application is as shown
-in Listing 13-8.
+먼저, 애플리케이션의 진정한 드라이버가 될 *Main.java* 클래스를 생성한다. Main.java의 목적은 자이썬 개체 팩토리 패턴을 사용하여 자이썬 기반 스윙 애플리케이션을 자바로 강제변형하는 것이다. 이 클래스는 애플리케이션의 시작점이며 자이썬 코드는 그 아래에서 모든 작업을 수행할 것이다. 이 패턴을 통하여, 자이썬 코드를 통하여 구현할 수 있는 자바 인터페이스가 필요하므로, 이 예제는 또한 GUI를 볼 수 있도록 하는 데에 쓰이는 *start()* 메소드를 구현하는 매우 간단한 인터페이스를 사용한다. 끝으로, 아래와 같은 이름의 자이썬 클래스는 *Main.java* 드라이버와 자바 인터페이스를 위한 코드이다. 이 애플리케이션의 디렉토리 구조는 예제 13-8에서와 같다.
 
-*Listing 13-8. Object Factory Application Code*
+*예제 13-8. Object Factory Application Code*
 
     **JythonSwingApp**
         **JythonSimpleSwing.py**
 
 
 
-As you can see, *Main.java* doesn’t do much else except coercing
-the Jython module and invoking the *start()* method. In Listing
-13-9, you will see the *JySwingType.java* interface along with the
-implementation class that is obviously coded in Jython.
+보는 바와 같이, *Main.java*\ 는 자이썬 모듈을 강제변형하고 *start()* 메소드를 호출하는 것 외에 별다른 일을 하지 않는다. 예제 13-9에서, *JySwingType.java* 인터페이스와 그것을 자이썬으로 구현한 클래스를 볼 수 있을 것이다.
 
-*Listing 13-9. JySwingType.java Interface and Implementation*
+*예제 13-9. JySwingType.java 인터페이스 및 구현*
 
 *JySwingType.java*
 ::
 
 
 
-If you are using Netbeans, when you clean and build your project a
-JAR file is automatically generated for you. However, you can
-easily create a JAR file at the command-line or terminal by
-ensuring that the *JythonSimpleSwing.py* module resides within your
-classpath and using the *java -jar* option. Another nice feature of
-using an IDE such as Netbeans is that you can make this into a
-web-start application by going into the project properties and
-checking a couple of boxes. Specifically, if you go into the
-project properties and select *Application - Web Start* from the
-left-hand menu, then check the *Enable Web Start* option then the
-IDE will take care of generating the necessary files to make this
-happen. Netbeans also has the option to self sign the JAR file
-which is required to run most applications on another machine via
-web start. Go ahead and try it out, just ensure that you clean and
-build your project again after making the changes.
+넷빈스를 사용한다면, 프로젝트를 clean 및 빌드할 때 JAR 파일이 자동으로 생성될 것이다. 명령행 또는 터미널에서는, *JythonSimpleSwing.py* 모듈이 클래스 경로 내에 있다면 *java -jar* 옵션을 사용하여 JAR 파일을 쉽게 생성할 수 있다. 넷빈스와 같은 IDE를 사용할 때에 좋은 또 다른 점은, 프로젝트의 속성에 대한 몇 가지 설정을 통하여 웹 스타트 애플리케이션을 만들 수 있다는 것이다. 구체적으로는, 프로젝트 속성으로 가서 왼쪽 메뉴에서 *Application - Web Start*\ 를 선택하고 *Enable Web Start* 옵션을 선택하면 필요한 파일의 생성을 IDE에서 처리해준다. 또한 넷빈스는 웹 스타를 통하여 다른 장비에서 애플리케이션을 구동할 때에 필요한 JAR 파일의 self sign 옵션을 갖고 있다. 한번 사용해보고, 변경을 가한 후에는 프로젝트를 clean 및 빌드하도록 하자.
 
-To manually create the necessary files for a web start application,
-you’ll need to generate two additional files that will be placed
-outside of the application JAR. Create the JAR for your project as
-you would normally do, and then create a corresponding JNLP file
-which is used to launch the application, and an HTML page that will
-reference the JNLP. The HTML page obviously is where you’d open the
-application if running it from the web. Listing 13-10 is some
-example code for generating a JNLP as well as embedding in HTML.
+웹 스타트 애플리케이션에서 필요한 파일을 수동으로 생성하려면, 애플리케이션 JAR의 외부에 둘 두 개의 부가적인 파일을 생성할 필요가 있다. 늘 하는 것과 같이 프로젝트를 위한 JAR를 생성하고, 애플리케이션을 구동시키는 데에 필요한 관련 JNLP 파일, 그리고 JNLP를 참조하는 HTML 페이지를 작성한다. 웹으로부터 애플리케이션을 실행시킨다면 원하는 위치에 HTML 페이지가 있어야 할 것이다. 예제 13-10는 HTML에 포함되는 것과 마찬가지로 JNLP를 생성하는 코드이다.
 
-*Listing 13-10. JNLP Code for Web Start*
+*예제 13-10. 웹 스타트를 위한 JNLP 코드*
 
 *launch.jnlp*
 ::
 
 
 
-In the end, Java web start is a very good way to distribute Jython
-applications via the web.
+결론적으로, 자바 웹 스타트는 자이썬 애플리케이션을 웹에 배포하는 데에 있어 매우 좋은 방법이다.
 
-Distributing via Standalone JAR
--------------------------------
+독립 JAR를 통한 배포
+--------------------
 
-It is possible to distribute a web start application using the
-Jython standalone JAR option. To do so, you must have a copy of the
-Jython standalone JAR file, explode it, and add your code into the
-file, then JAR it back up to deploy. The only drawback to using
-this method is that you may need to ensure files are in the correct
-locations in order to make it work correctly, which can sometimes
-be tedious.
+자이썬 독립실행 JAR 옵션을 사용하여 웹 스타트 애플리케이션을 배포하는 것이 가능하다. 그렇게 하기 위해서는, 자이썬 독립실행 JAR 파일의 사본이 필요하며, 그것을 explode하고, 그 파일에 여러분의 코드를 추가하고, 배포를 위하여 다시 JAR로 만든다. 파일들이 올바른 경로에 있는지 확인해야하며, 때로는 tedious할 수 있다는 것이 유일한 drawback이다.
 
-In order to distribute your Jython applications via a JAR, first
-download the Jython standalone distribution. Once you have this,
-you can extract the files from the *jython.jar* using a tool to
-expand the JAR such as Stuffit or 7zip. Once the JAR has been
-exploded, you will need to add any of your *.py* scripts into the
-*Lib* directory, and any Java classes into the root. For instance,
-if you have a Java class named *org.jythonbook.Book*, you would
-place it into the appropriate directory according to the package
-structure. If you have any additional JAR files to include with
-your application then you will need to make sure that they are in
-your classpath. Once you’ve completed this setup, JAR your
-manipulated standalone Jython JAR back up into a ZIP format using a
-tool such as those noted before. You can then rename the ZIP to a
-JAR. The application can now be run using the java “-jar” option
-from the command line using an optional external *.py* file to
-invoke your application.
+JAR를 통하여 자이썬 애플리케이션을 배포하기 위해서는, 먼저 자이썬 독립실행 배포본을 다운로드한다. 그런 다음에는, JAR를 expand하는 Stuffit 또는 7zip 등의 도구를 사용하여 *jython.jar*로부터 파일을 풀어낸다. JAR를 explode한 후에는, 여러분의 *.py* 스크립트들은 *Lib* 디렉토리에, 자바 클래스들은 루트에 추가한다. 예를 들어 *org.jythonbook.Book*\ 이라는 이름의 자바 클래스가 있다면, 그것을 패키지 구조에 따른 적절한 디렉토리에 위치시킨다. 애플리케이션에 추가적으로 포함시킬 JAR 파일이 있다면 그것들을 classpath에 두도록 해야한다. 이 셋업을 마치면, 조작된 독립실행 자이썬 JAR를 앞서 기술한 도구들을 사용하여 다시 ZIP 형식으로 JAR한다. 그런 다음 ZIP을 JAR로 이름을 바꾼다. 이제 애플리케이션은 명령행에서 여러분의 애플리케이션을 호출하기 위한 추가적인 외부의 *.py* 파일을 사용하여 "-jar" 옵션을 사용하여 수행시킬 수 있게 되었다.
 
 ::
     
     $ java -jar newStandaloneJar.jar {optional .py file}
 
-This is only one such technique used to make a JAR file for
-containing your applications. There are other ways to perform such
-techniques, but this seems to be the most straight forward and
-easiest to do.
+이것은 여러분의 애플리케이션을 담기 위하여 JAR 파일을 사용하는 한 가지의 예일 뿐이다. 그러한 기법을 수행하는 다른 방법도 있지만, 이것이 가장 직관적이고 쉽게 할 수 있는 방법이다.
 
-WSGI and Modjy
-==============
+WSGI와 Modjy
+============
 
-WSGI, also known as the *Web Server Gateway Interface*, is a
-low-level API that provides communication between a web server and
-a web application. Actually, WSGI is a lot more than that and you
-can actually write complete web applications using WSGI. However,
-WSGI is more of a standard interface to call python methods and
-functions. Python PEP 333 specifies the proposed standard interface
-between web servers and Python web applications or frameworks, to
-promote web application portability across a variety of web
-servers.
+*웹 서버 게이트웨이 인터페이스*의 약자인 WSGI는, 웹 서버와 웹 애플리케이션 간의 통신을 제공하는 저수준 API이다. 사실, WSGI는 그 이상이며 WSGI를 사용하여 완전한 웹 애플리케이션을 실제로 작성할 수 있다. 하지만 WSGI는 파이썬 메소드와 함수르 호출하는 표준 인터페이스에 가깝다. 파이썬 PEP 333은 다양한 웹 서버들 사이에서 웹 애플리케이션의 이식성을 높이기 위하여 제안된, 웹 서버들과 파이썬 웹 애플리케이션 또는 프레임워크 사이의 표준 인터페이스를 기술한다.
 
-This section will show you how to utilize WSGI to create a very
-simple “Hello Jython” application by utilizing *modjy*. Modjy is an
-implementation of a WSGI compliant gateway/server for Jython, built
-on Java/J2EE servlets. Taken from the modjy website
-(http://opensource.xhaus.com/projects/modjy/wiki), modjy is
-characterized as follows:
+이 섹션에서는 *modjy*\ 를 활용하여 매우 간단한 "Hello Jython" 애플리케이션을 생성하기 위하여 WSGI를 활용하는 방법을 보인다. Modjy는 자이썬을 위한 WSGI compliant 게이트웨이/서버로서, Java/J2EE 서블릿에 기반하고 있다. modjy 웹사이트(http://opensource.xhaus.com/projects/modjy/wiki)에 의하면, modjy는 다음과 같이 묘사된다.
 
 .. note::
-    Jython WSGI applications run inside a Java/J2EE container and incoming requests are handled by the servlet container. The container is configured to route requests to the modjy servlet. The modjy servlet then creates an embedded Jython interpreter inside the servlet container, and loads a configured Jython web application. For instance, a Django application can be loaded via modjy. The modjy servlet then delegates the requests to the configured WSGI application or framework. Lastly, the WSGI response is routed back to the client through the servlet container.
+    Java/J2EE 컨테이너 내부에서 동작하는 자이썬 WSGI 애플리케이션이며 들어오는 요청은 서블릿 컨테이너에서 처리된다. 컨테이너는 요청을 modjy 서블릿으로 라우트하기 위하여 구성된다. 그러면 modjy 서블릿은 서블릿 컨테이너 내에 임베드된 자이썬 인터프리터를 생성하고, 구성된 자이썬 웹 애플리케이션을 적재한다. 예를 들어, 장고 애플리케이션이 modjy를 통하여 적재될 수 있다. 그러면 modjy 서블릿은 구성된 WSGI 애플리케이션 또는 프레임워크로 요청을 위임한다. 끝으로, WSGI 응답은 서블릿 컨테이너를 거쳐 클라이언트로 다시 라우트된다.
 
 
-Running a Modjy Application in Glassfish
-----------------------------------------
+글래스피쉬에서 Modjy 애플리케이션 구동
+--------------------------------------
 
-To run a modjy application in any Java servlet container, the first
-step is to create a Java web application that will be packaged up
-as a WAR file. You can create an application from scratch or use an
-IDE such as Netbeans 6.7 to assist. Once you’ve created your web
-application, ensure that *jython.jar* resides in the CLASSPATH as
-modjy is now part of Jython as of 2.5.0. Lastly, you will need to
-configure the modjy servlet within the application deployment
-descriptor (web.xml). In this example, we took the modjy sample
-application for Google App Engine and deployed it in my local
-Glassfish environment.
+modjy 애플리케이션을 자바 서블릿 컨테이너에서 구동하기 위한 첫 번째 단계는 WAR 파일로 포장할 자바 웹 애플리케이션을 생성하는 것이다. 다른 도구의 도움 없이 애플리케이션을 작성할 수도 있고 넷빈스 6.7과 같은 IDE의 도움을 받을 수도 있다. modjy는 2.5.0 버전 이후부터 자이썬에 포함되므로, 일단 웹 애플리케이션을 작성한 후에는 *jython.jar*\ 가 CLASSPATH에 있도록 해야한다. 끝으로, 애플리케이션 배포 기술자 (web.xml) 내에 modjy 서블릿에 대하여 설정할 필요가 있다. 이 예제에서는, 구글 앱 엔진을 위한 modjy 애플리케이션을, 로컬의 글래스피쉬 환경에 배포할 것이다.
 
-To configure the application deployment descriptor with modjy, we
-simply configure the modjy servlet, provide the necessary
-parameters, and then provide a servlet mapping. In the
-configuration file shown in Listing 13-11, note that the modjy
-servlet class is *com.xhaus.modjy.ModjyServlet*. The first
-parameter you will need to use with the servlet is named
-*python.home*. Set the value of this parameter equal to your Jython
-home. Next, set the parameter *python.cachedir.skip* equal to true.
-The *app_filename* parameter provides the name of the application
-callable. Other parameters will be set up the same for each modjy
-application you configure. The last piece of the web.xml that needs
-to be set up is the servlet mapping. In the example, we set up all
-URLs to map to the modjy servlet.
+modjy를 위한 애플리케이션 배포 기술자를 설정하기 위해서는, modjy 서블릿을 설정하고, 필요한 매개변수를 제공한 다음, 서블릿 매핑을 제공한다. 예제 13-11에 나타난 구성에서, modjy 서블리 클래스는 *com.xhaus.modjy.ModjyServlet*\ 이다. 서블릿에서 필요로하는 첫 번째 매개변수의 이름은 *python.home*\ 이다. 이 매개변수의 값은 자이썬 홈과 같다. 다음으로, *python.cachedir.skip* 매개변수는 true로 한다.
+*app_filename* 매개변수에는 호출할 수 있는 애플리케이션의 이름을 넣는다. 다른 매개변수는 여러분이 설정하는 각 modjy 애플리케이션과 똑같이 설정될 것이다. web.xml의 끝 부분에는 서블릿 매핑이 필요하다. 예제에서, 모든 URL을 modjy 서블릿에 매핑한다.
 
-*Listing 13-11. Configuring the Modjy Servlet*
+*예제 13-11. Configuring the Modjy Servlet*
 
 *web.xml*
 ::
                 <param-value>my_handler_func</param-value>
             </init-param>
             -->
-            <!-- Do you want application callables to be cached? -->
+            <!-- Do you want application callables to be cached?-->
             <init-param>
                 <param-name>cache_callables</param-name>
                 <param-value>1</param-value>
             </init-param>
-            <!-- Should the application be reloaded if it's .py file changes?
-            -->
+            <!-- Should the application be reloaded if it's .py file changes?            -->
             <!-- Does not work with the app_import_name mechanism -->
             <init-param>
                 <param-name>reload_on_mod</param-name>
 
 
 
-The demo_app should be coded as shown in Listing 13-12. As part of
-the WSGI standard, the application provides a function that the
-server calls for each request. In this case, that function is named
-*handler*. The function must take two parameters, the first being a
-dictionary of CGI-defined environment variables. The second is a
-callback that returns the HTTP headers. The callback function
-should also be called as follows
-*start_response(status, response_headers, exx_info=None)*, where
-status is an HTTP status, response_headers is a list of HTTP
-headers, and exc_info is for exception handling. Let’s take a look
-at the *demo_app.py* application and identify the features we’ve
-just discussed.
+demo_app은 예제 13-12에 보인 것과 같이 작성되어야 한다. WSGI 표준의 일부로서, 애플리케이션은 각 요청에 대한 서버 호출 함수를 제공한다. 이 경우, 그 함수의 이름은 *handler*\ 이다. 그 함수는 두 매개변수를 취하여야 하며, 첫 번째 것은 CGI 정의 환경 변수 사전이 되어야 한다. 두 번째는 HTTP 헤더를 반환하는 콜백이다. 그 콜백 함수는 *start_response(status, response_headers, exx_info=None)*\ 과 같이 호출되어야 하며, 이때 status는 HTTP 상태, response_headers는 HTTP 헤더의 목록, 그리고 exc_info는 예외처리를 위한 것이다. *demo_app.py* 애플리케이션을 살펴보고 방금 논의한 기능을 확인하도록 하자.
 
-*Listing 13-12.*
+*예제 13-12.*
 ::
     
     import sys
         return [response_text.substitute(version=sys.version, platform=sys.platform)]
 
 
-This application returns the environment configuration for the
-server on which you run the application. As you can see, the page
-is quite simple to code and really resembles a servlet.
+이 애플리케이션은 그것이 동작하는 서버의 환경 구성을 반환한다. 보는 바와 같이, 페이지는 코딩하기가 아주 단순하며 서블릿과 정말로 흡사하다.
 
-Once the application has been set up and configured, simply compile
-the code into a WAR file and deploy it to the Java servlet
-container of your choice. In this case, we used Glassfish V2 and it
-worked nicely. However, this same application should be deployable
-to Tomcat, JBoss, or the like.
+애플리케이션이 일단 셋업되고 구성되면, 간단히 컴파일하여 WAR 파일을 만들고 여러분이 선택한 자바 서블릿 컨테이너에 배포하도록 한다. 이 경우에는, 우리는 글래스피쉬 V2를 사용하여 잘 작동하였다. 하지만, 동일한 애플리케이션이 톰캣, JBoss 등에 대해서도 배포 가능할 것이다.
 
-Summary
-=======
+요약
+====
 
-There are various ways that we can use Jython for creating simple
-web-based applications. Jython servlets are a good way to make
-content available on the web, and you can also utilize them along
-with a JSP page which allows for a Model-View-Controller situation.
-This is a good technique to use for developing sophisticated web
-applications, especially those mixing some JavaScript into the
-action because it really helps to organize things. Most Java web
-applications use frameworks or other techniques in order to help
-organize applications in such a way as to apply the MVC concept. It
-is great to have a way to do such work with Jython as well.
+간단한 웹 기반 애플리케이션을 생성하는 데에 자이썬을 사용할 수 있는 여러 방법이 있다. 자이썬 서블릿은 컨텐트를 웹에서 사용가능하도록 하는 데에 좋은 방법이며, 모델-뷰-컨트롤러 구성을 가능하게 해주는 JSP 페이지와 함께 활용할 수도 있다.
+이것은 정교한 웹 애플리케이션을 개발하기에 좋은 기법이며, 특히 자바스크립트와 혼합하여 액션을 만들 때에 효과적으로 관리할 수 있다. 많은 자바 웹 애플리케이션은 MVC의 개념을 적용할 수 있도록 해주는 프레임워크 등의 기법을 사용한다. 자이썬으로도 그와 같은 일을 잘 해낼 수 있다.
 
-This chapter also discussed creation of WSGI applications in Jython
-making use of modjy. This is a good low-level way to generate web
-applications as well, although modjy and WSGI are usually used for
-implementing web frameworks and the like. Solutions such as Django
-use WSGI in order to follow the standard put forth for all Python
-web frameworks with PEP 333. You can see from the section in this
-chapter that WSGI is also a nice quick way to write web
-applications, much like writing a servlet in Jython.
+또한 이 장에서는 modjy를 사용하는 자이썬에서의 WSGI 애플리케이션의 생성에 대하여 논의하였다. 이는 저수준에서 웹 애플리케이션을 생성하는 데에 있어 좋은 방법이며, modjy와 WSGI가 웹 프레임워크 등을 구현하는 데에 사용되곤 한다. 장고와 같은 솔루션은 파이썬 웹 프레임워크의 표준 PEP 333을 따르는 WSGI를 사용한다. WSGI 또한 자이썬으로 서블릿을 작성하는 것만큼이나 웹 애플리케이션을 작성하는 데에 있어 훌륭하고도 재빠른 방법임을 알 수 있을 것이다.
 
-In the next chapters, you will learn more about using web
-frameworks available to Jython, specifically Django and Pylons.
-These two frameworks can make any web developers life much easier,
-and now that they are available on the Java platform via Jython
-they are even more powerful. Using a templating technique such as
-Django can be really productive and it is a good way to design a
-full-blown web application. Techniques discussed in this chapter
-can also be used for developing large web applications, but using a
-standard framework such as those discussed in the following chapter
-should be considered. There are many great ways to code Jython web
-applications today, and the options continue to grow!
-
-
-
-
+다음 장부터는 자이썬에서 사용할 수 있는 웹 프레임워크, 특히 장고와 파일론에 대하여 배울 것이다.
+그 두 가지 프레임워크는 웹 개발을 보다 쉽게 만들어주며, 자이썬을 통하여 자바 플랫폼을 활용함으로써 더욱 강력해진다. 장고와 같은 템플릿 기법을 사용하여 훨씬 생산적이 되며, 이는 full-blown 웹 애플리케이션을 디자인하는 데에 있어 좋은 방법이다. 이 장에서 논의한 기법들을 사용하여 규모가 큰 웹 애플리케이션을 개발하는 것도 가능하지만, 그보다는 앞으로 다룰 표준 프레임워크의 사용을 우선적으로 고려하여야 할 것이다. 자이썬 웹 애플리케이션을 작성하는 데에 좋은 여러 방법이 있으며, 계속 발전해나가고 있다!