Launch Java Applications from Assembly Language Programs

[출처] http://today.java.net/pub/a/today/2007/10/04/launch-java-applications-from-assembly-language-programs.html

October 4, 2007

Biswajit Sarkar

• Contents
• • Why Java with ASM?
  • Recommended Downloads
  • The Basics
  • The Macros
  • Creating a JVM Instance
  • Locating the Class
  • Getting the Method ID
  • Calling the Target Method
  • Conclusion
  • Resources

Java Native Interface (JNI) is a mechanism that can be used to establish communication between native language programs and the Java virtual machine. The 　documentation for JNI and the technical literature on JNI deal extensively with interactions between the JVM and C/C++ code. The Java SDK even provides a utility to generate a header file to facilitate calling C/C++ programs from Java code. However, there is hardly any mention of Java andassembly language code working together. In an earlier article I showed how assembly language programs can be called from Java applications. Here I deal with the technique for invoking Java programs from an ASM process through a demo application that calls a Java method from assembly language code. The Java method brings up a Swing JDialog to show that it has, indeed, been launched.

Why Java with ASM?

JNI is essential to the implementation of Java, since the JVM needs to interact with the native platform to implement some of its functionality. Apart from that, however, use of Java classes can often be an attractive supplement to applications written in other languages, as Java offers a wide selection of APIs that makes implementation of advanced functions very simple.

Some time ago, I was associated with an application to collect real-time data from a number of sources and save them in circular buffers so that new data would overwrite old data once the buffer got filled up. If a designated trigger event was sensed through a digital input, a fixed number of data samples would be saved in the buffers so that a snapshot of pre- and post-trigger data would be available. The original application was written in assembly language. After the application was used for a few months, it was felt that it would be very useful to have the application mail the snapshots to authorized supervisors whenever the trigger event occurred. Of course, it would have been possible to write this extension in assembly, but the team felt that in that particular instance it was easier to write that extension in Java and hook it up with the ASM program. As I had earlier worked with ASM-oriented JNI, I knew this could be done and, indeed, the project was implemented quickly and successfully.

I am sure there are many legacy applications written in assembly language that could benefit from such add-ons. However, it is not only for old applications in need of renovation that JNI can prove useful. Although it may seem unlikely to some of us, assembly language is still used for writing selected portions of new programs. In an article published not very long ago, the author says, "I have found that many of Sun's partners still use assembly language in their products to ensure that hot code paths are as efficient as possible. While compilers are able to generate much more efficient code today, the resulting code still doesn't always compete with hand-coded assembly written by an engineer that knows how to squeeze performance out of each microprocessor instruction. Assembly language remains a powerful tool for optimization, granting the programmer greater control, and with judicious use can enhance performance." Clearly, in such "mixed language" applications the ability to use Java with ASM can be useful.

Note that the technique shown here can also be used to call Java code from languages other than ASM. If JInvoke is rewritten as a .dll, code written in FORTRAN, for instance, can link to it and call a Java method.

I have used JNI with legacy ASM code in two ways:

• Functional enhancement: Mail-enabling an existing ASM application, as mentioned earlier.
• Interface enhancement: Adding interactive user interface (mostly AWT, but some Swing as well).

These enhanced applications have run on Windows 2000 and XP. The Java versions used were 1.3, 1.4, and 1.6. In all cases the applications worked smoothly.

Recommended Downloads

The version of assembly language I have used for the demo code is MASM32. The entire MASM32 bundle is a free download, and if you are going to experiment with Java-ASM interaction, you will need to have it on your computer. A set of extremely useful tutorials on MASM programming are available on Iczelion's site. The definitive work on JNI is Sheng Liang's book The Java Native Interface: Programmer's Guide and Specification. This too is a free download. This article's Java code sample,AsmToJava, will obviously need an SDK (or, at least, a JRE) for execution. The assembly language part of the demo, JInvoke, has been compiled into an .exe file and will run even without the MASM bundle; the assembler/linker is required only if you want to modify the source code and recompile it.

The Basics

JNI provides a comprehensive interface to a JVM. This interface is exposed primarily through a rich set of functions. Native code can call these functions to interact with a JVM implementation. These functions are described in detail in Sheng Liang's book. While most of these functions can be accessed only after a JVM has been created, JNI also directly exports a number of native functions. As we shall see later, a function of the second type can be used to instantiate a JVM, so that other JNI functions can be called.

Once a JVM has been created, an assembly language program can access those JNI functions that need a JVM instance to implement their functionalities. Pointers to all these JNI functions are stored in a table, the Function Table. When the ASM code loads a JVM, it receives a variable named JNIEnv, which is really a pointer. JNIEnv points to a memory location that, in turn, contains the actual pointer to the Function Table. This chain of access is shown in Figure 1.

Figure 1. Access to JNI functions

As we see, each of the pointers to JNI functions is four bytes long. So the pointer to any given function can be found at the location defined by adding four times the index for that function to the starting address of the function table. The function indices are zero-based--the pointer for the first function is at index 0, that for the second is at index 1, and so on. In his book, Sheng Liang lists the index values for all JNI functions.

To call a Java program, ASM code needs to execute the following steps:

• Instantiate a JVM
• Locate the class
• Get the ID of the method
• Call the method

Before we look at these steps in detail, let us check out how we can use an include file to simplify the task of writing this and similar programs. As interactions between Java and native codes take place through the functions exposed by JNI, it becomes necessary for native processes to call these functions repeatedly. So we would like to use macros to take care of these activities. That would reduce the need for repeatedly writing similar (and fairly long) code and would also reduce the chances of bugs getting into the program through typos.

The Macros

Calling a function from ASM code involves getting the pointer to the function from the Function Table and then calling the function using that pointer. Getting the pointer, as we know, involves following the JNIEnv pointer chain to obtain the starting address of the Function Table and then retrieving the pointer to the desired function by using the index of the function. The first part--getting the starting address of the Function Table--would use identical code every time and can be handled by the following macro:

    ;This macro returns the pointer to     ;Function Table in fnTblPtr    GetFnTblPtr MACRO envPtr, fnTblPtr        mov ebx, envPtr        mov eax, [ebx]        mov fnTblPtr, eax    ENDM

The code shown above defines a macro that takes two parameters. The first is the JNIEnv pointer and the second points to the location where the macro will return the pointer to Function Table. The macro loads the pointer to Function Table intoeax, which is then saved in fnTblPtr. One way of using this macro would be to define it within the program itself. Another way, adapted here, is to define all such macros within an include file, which can then be used with the ASM program through an include statement. The include file used here is jav_asm.inc. This file defines not only theGetFnTblPtr macro, but also all the others that are required for this example. In addition to the macros,jav_asm.inc defines the prototype of the function that creates a JVM as well as the structs that are to be used as parameters with that function. Finally, java_asm.incassigns symbolic names to all JNI function indices to simplify their use.

Once the pointer to the Function Table has been obtained, the pointer to the desired function needs to be retrieved. The code for this too will be the same every time except for the index. The following macro performs this task:

    ;This macro returns the pointer     ;to a function in fnPtr.        GetFnPtr MACRO fnTblPtr, index, fnPtr                mov eax, index                mov ebx, 4                mul ebx                mov ebx, fnTblPtr                add ebx, eax                mov eax, [ebx]                mov fnPtr, eax        ENDM

The macro multiplies the value of index by 4 and adds the result to the starting address of Function Table (available in fnTblPtr) to get the pointer to the function we want to access. This pointer is then saved infnPtr.

The three remaining macros are almost identical; the only difference is in the number of parameters handled:

    ;The next 3 macros push parameters as per     ;stdcall and call the function through fnPtr        CallFunction2 MACRO param1, param2, fnPtr                push param2                push param1                call [fnPtr]        ENDM        CallFunction3 MACRO param1, param2, param3, fnPtr                push param3                push param2                push param1                call [fnPtr]        ENDM        CallFunction4 MACRO param1, param2, param3, param4, fnPtr                push param4                push param3                push param2                push param1                call [fnPtr]        ENDM

As we see, these macros push the parameters (exceptfnPtr) in reverse order as required forstdcall, and then call the targeted function usingfnPtr as the pointer.

Now that the basic building blocks are in place, we can take a look at the four-step sequence followed by our demo application.

Creating a JVM Instance

JInvoke creates an instance of JVM more or less in the same way as the java command does when we launch a Java application from the command line. A Java virtual machine implementation offers a mechanism known as the Invocation Interface that allows a native application to load the virtual machine. The java command calls a C program that uses the Invocation Interface to run a Java application, andJInvoke uses this same interface. The code for loading the JVM is given below:

    .    .    .    va          vm_args <>    jvmo        JavaVMOption <>    .    .    .    mov jvmo.optionString, offset opzero    mov va.options, offset jvmo    mov va.version, 00010002h    mov va.nOptions,1    mov va.ignoreUnrecognized, TRUE    invoke JNI_CreateJavaVM, offset JavaVM, offset JNIEnv,         offset va

Here we first declare two structs. As we have already seen, these structs are defined in jav_asm.inc. The creation of a JVM requires that a number of parameters be specified. These are passed to the JNI_CreateJavaVM function through the structs.

In our example, we want to invoke the main method of the AsmToJava class. On my computer, the class file is in the C:\j2sdk1.4.2_05\testjni folder. The stringopzero defines this path in accordance with the method described in the JNI specs. Note that opzero is loaded into the struct jvmo, and then the offset tojvmo is loaded into the struct va. The last parameter passed to the JNI_CreateJavaVM function is va and, therefore, the JVM that is loaded comes to know where to find the class that we are interested in.

When JNI_CreateJavaVM returns, it signals success by returning zero in eax and failure by returning a negative number in eax. If the function succeeds in creating the JVM instance, the pointer to the JVM interface and the corresponding JNIEnv pointer are available inJavaVM and JNIEnv, respectively.

On return from the JNI_CreateJavaVM function,JInvoke checks the content of eax. If it is not zero, the JVM has not been loaded. The user is informed of this and the process exits:

    .if eax == 0        .        .        .    .else        invoke MessageBox, 0, addr Fail1Text,             addr Caption, 16; failed to create JVM    .endif 

On the other hand, if the content of eax is zero, then a message box is shown (Figure 2) with the corresponding message and the next step is executed:

    .if eax == 0        invoke MessageBox, 0, addr VmText,             addr Caption, 64; indicate success

Figure 2. Message to show that the JVM has been loaded

I must point out here that JInvoke uses the simplest approach to JVM instantiation since it is meant to be a vehicle for concept demonstration only. A number of additional parameters can be specified, as is explained by Sheng Liang in his book.

Locating the Class

After loading the JVM, JInvoke needs to locate the class that is the entry point for the target Java application. The following code calls the FindClass function to do this:

    GetFnTblPtr JNIEnv, fntblptr    GetFnPtr fntblptr, FI_FC, fnptr ; ptr to FindClass    CallFunction2 JNIEnv, offset ProcName,         fnptr ; call FindClass    .if eax != 0        mov classid, eax        invoke MessageBox, 0, addr FcText,             addr Caption, 64; class found

Note that the path to the class was earlier loaded into the struct jvmo (mov jvmo.optionString, offset opzero) and is already known to the JVM. If the FindClass function is able to locate the class, it returns the ID in eax. Otherwise it returns zero. Once the class is located, its ID is saved and a message box so informs the user (Figure 3).

Figure 3. Message to show that the class has been found

If the class cannot be located, then the process exits after showing an appropriate message. Figure 4 is an example of a message shown when a called function does not succeed.

Figure 4. Message to show that the class could not be found

Getting the Method ID

In order to call the method, the corresponding ID has to be obtained. The function that returns the ID for a static method isGetStaticMethodID. We use this function here since we want to call the main method of theAsmToJava class. The parameters for this function--in addition to JNIEnv--are:

• The ID of the class to which the method belongs; this is theclassid variable referred to in the previous step.
• The name of the method; this is the stringmethodname.
• The descriptor of the method that specifies the parameters for the method and its return type; the string methodsig is the descriptor for our target method. In this case, the parameter is a String array and the return type isvoid. Sheng Liang's book on the JNI specification shows how to create descriptors for methods and for variables too.

The call to GetStaticMethodID is very similar to the other function calls we have seen so far:

    GetFnPtr fntblptr, FI_GSMID, fnptr ; ptr to GetStaticMethodID    CallFunction4 JNIEnv, classid, offset methodname,         offset methodsig, fnptr ; GetStaticMethodID    .if eax != NULL        mov methid, eax        invoke MessageBox, 0, addr GsmiText, addr Caption, 64

GetStaticMethodID returns the ID ineax. If the attempt to obtain the method ID is unsuccessful then NULL is returned instead. So JInvokechecks the content of eax to determine whether to go on to the next step (Figure 5) or exit the process.

Figure 5. Message to show that method ID has been obtained

Calling the Target Method

The JNI function that calls a static method with the return typevoid (remember, we are calling the mainmethod) is CallStaticVoidMethod. The following code gets the pointer to this function and calls it with the required parameters:

    GetFnPtr fntblptr, FI_CSVM, fnptr ; get CallStVM ptr    CallFunction3 JNIEnv, classid, methid, fnptr; call CallStVM

The Java application displays a dialog to show that it has been successfully launched.

Figure 6. Java method successfully invoked

Once the called Java method returns, JInvokeexits.

Figure 7. Message to show that the process is exiting

When the ExitProcess function is called, all threads in the process are stopped, so the Java threads created by the process will also be stopped. Therefore, if this approach is used to launch a Java program, care must be taken to ensure that the called Java method returns only after completing all required activities. Actually, the issues involved in terminating the calling process and the JVM need careful attention. Please refer to the Windows API 　documentation and the latest JNI specs.

Conclusion

The approach shown here demonstrates the basic technique used for launching Java applications from assembly language code. Adequate error checking should be incorporated in native programs to ensure safe interaction with the Java environment. Sheng Liang provides many examples of checks including handling of exceptions in native code. ASM programs working with JNI should use such error checking methods wherever applicable.

The jav_asm.inc file provides an easy way of specifying JNI function indices. The use of symbolic names instead of numbers to specify an index is less likely to lead to errors. The use of macros, too, is useful in reducing errors. You are free to use this file with your code and also to modify it to suit your requirements. However, make sure that the file is not redistributed without the disclaimer.

When running JInvoke, you may get an error message saying that jvm.dll cannot be located. If this happens, you need to add the path to the directory containing jvm.dllto your PATH environment variable. This DLL is normally located in the jre\bin\client directory under the Java SDK root folder. For instance, on my computer, the path isC:\j2sdk1.4.2_05\jre\bin\client for the Java 1.4 release. If you are using Java 1.3, however, the folder would bejre\bin\classic. So make sure you've got the right path.

Finally, I would like to point out that the paths to the files named in the include statements ofJInvoke would be determined by the directory structure of your computer. The paths specified in JInvoke are valid for my computer. As far as JInvoke.exe is concerned, it will run even without any MASM component (specifically, any .inc or .lib file) being loaded into your system. If you want to modify the code and recompile it, you will have to make sure that the path details correspond to the way your directories are set up. The AsmToJava class file will have to be loaded in the directory specified byopzero. Alternately, opzero will have to be changed to reflect the path to this class. In that case, the source file for JInvoke will need to be recompiled, keeping in mind the need to modify other path names as mentioned above.

Resources

• src.zip: Source code forJInvoke and AsmToJava, JInvoke.exe, the AsmToJava class file and the jav_asm.incfile.
• "Invoking Assembly Language Programmes from Java Applications." This article provides supplementary information and explanation which may be useful.
• The Java™ Native Interface Programmer's Guide and Specification, by Sheng Liang.
• Iczelion's home page

Biswajit Sarkar is an electrical engineer with specialization in Programmable Industrial Automation. Biswajit is the author of "LWUIT 1.1 for Java ME Developers" published by PACKT Publishing.

Introduction

Android source code is maintained in two code bases: the Android Linux kernel (kernel directory) and Android platform and applications (device directory). This 　document provides a high-level introduction to the source code organization and an overview of the major components of each primary directory.

Android Source

Linux Kernel

The Android Linux kernel includes enhancements to the Linux 2.6 kernel that provide additional drivers to support the Android platform, including:

• Binder: an OpenBinder-based driver to facilitate inter-process communication (IPC) in the Android platform.
• Android Power Management: a light weight power management driver built on top of standard Linux power management but optimized for embedded systems.
• Low Memory Killer: Based on hints from the userspace, the low memory killer can kill off processes to free up memory as necessary. It is designed to provide more flexibility than the Out Of Memory (OOM) killer in the standard kernel.
• Logger: A light weight logging device used to capture system, radio, logdata, etc.
• USB Gadget: Uses the USB function framework.
• Android/PMEM: The PMEM (physical memory) driver is used to provide contiguous physical memory regions to userspace libraries that interact with the digital signal processor (DSP) and other hardware that cannot cope with scatter-gather.
• Android Alarm: A driver which provides timers that can wake the device up from sleep and a monotonic timebase that runs while the device is asleep.

Look for Android-specific enhancements in the following directories:

• /drivers/android
• /drivers/misc
• /include/linux

Android Platform and Applications

The following list outlines the directory structure found within the device branch of Android source code:

• apps : Core Android applications such as Phone, Camera, and Calendar.
• boot : Reference Android bootloader and other boot-related source code.
• commands : Common Android commands, the most important of which is the runtime command, which does much of the initialization of the system.
• config : System-wide makefiles and linker scripts.
• content : Standard Android ContentProvider modules.
• dalvik : Android runtime Virtual Machine (VM).
• data : Fonts, keymaps, sounds, timezone information, etc.
• docs : Full set of Android 　documentation.
• extlibs : Non-Android libraries. This directory is intended to host unmodified external code. None of the libraries included within this directory rely on Android headers or libraries.
• ide : Tools for support of the IDE's used to write Android applications.
• include : Android system headers for inclusion.
• java : Android core APIs, as well as some external libraries.
• libs : Android-specific C++ based libraries.
• partner : Project-specific source code for various proprietary components.
• prebuilt : Prebuilt tools, like the toolchains and emulator binary.
• product : Device-specific configuration files. This directory will include a subdirectory for each new device.
• samples : Sample applications.
• servers : C++ based system servers.
• system : Core of the embedded Linux platform at the heart of Android. These essential bits are required for basic booting, operation, and debugging.
• tests : Platform and application test cases.
• tools : Tools for building and debugging Android (of particular interest for porting are "adb" and "emulator").

Java Spring 2.0 Web 예제(Hello World)

0. http://www.springsource.org/download 링크를 따라가서

spring-framework-2.5.6-with-dependencies.zip 을 다운받아 압축 해제한다.

1. 이클립스에서 File -> New -> Dynamic Web Project -> hellospring 이라고 하자.

2. WEB-INF -> lib 폴더에 아래 그림처럼 jar 파일을 복사한다.

1) 압축 해제 폴더\dist\spring.jar

2) 압축 해제 폴더\dist\modules\spring-webmvc.jar

3) 압축 해제 폴더\lib\jakarta-commons\commons-logging.jar

3. web.xml 을 아래와 같이 수정한다.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>hellospring</display-name>
<servlet>
<servlet-name>spring2</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>spring2</servlet-name>
<url-pattern>*.htm</url-pattern>
</servlet-mapping>

<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
</web-app>

4. Java Resource: src -> 우클릭 -> New -> Class

아래 소스 작성

package hellospring.web;

import! javax.servlet.http.HttpServletRequest;
import! javax.servlet.http.HttpServletResponse;
import! org.apache.commons.logging.Log;
import! org.apache.commons.logging.LogFactory;
import! org.springframework.web.servlet.ModelAndView;
import! org.springframework.web.servlet.mvc.Controller;

public class HelloController implements Controller {
protected final Log logger = LogFactory.getLog(getClass());

@Override
public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception {
logger.info("hello 예제 정상 작동");//로그 메세지 보여준다.
request.setAttribute("name", "홍길동");//name 홍길동 셋팅.
return new ModelAndView("hello.jsp");//hello.jsp 로 가라.
}
}

5. WebContent -> 우클릭 -> JSP -> hello.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Hello Spring 예제</title>
</head>
<body>
<h3>Hello Spring 예제</h3>
Hello!!! <%=request.getAttribute("name") %>
</body>
</html>

6. WEB-INF -> 우클릭 -> spring2-servlet.xml -> [Finish]

규칙 : web.xml 에서 정의한 서블릿 이름인 spring2-servlet.xml 로 만들어야 한다.

아래의 소스를 작성한다. (url 인 /hello.htm 을 처리할 클래스 HelloController 에 맵핑시킨다..)

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

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<bean name="/hello.htm" class="hellospring.web.HelloController"/>

</beans>

7. 서버 시작 후 http://localhost:8080/hellospring/hello.htm 테스트.

kernel.org가 아닌 구글에서 안드로이드 소스 다운로드 및 빌드

* 결국 kernel.org는 복구가 안돼네요. 구글에서 안드로이드 소스를 공유하기로 하고,

제 3자인 kernel.org에 소스를 위탁했던 것 같은데, 이젠 구글에서 직업 배포합니다.

* Linux 64bit version을 컴퓨터에 설치 후

소스만 2GB이므로 빌드 환경을 위해서는 10GB 이상이 요구됩니다.

* 1. JDK 설치

$ sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu hardy main multiverse"
$ sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu hardy-updates main multiverse"
$ sudo apt-get update
$ sudo apt-get install sun-java5-jdk

sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo add-apt-repository "deb-src http://archive.canonical.com/ubuntu lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk

* 2. 빌드 환경을 위한 유틸리티 설치

$ sudo apt-get install git-core gnupg flex bison gperf build-essential \
zip curl zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs \
x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \
libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown \
libxml2-utils

* 3. 소스 다운로드를 위한 repo 설치

$ mkdir ~/bin
$ PATH=~/bin:$PATH
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
$ chmod a+x ~/bin/repo

* 4. repo 초기화

$ repo init -u https://android.googlesource.com/platform/manifest

* 5. 소스 다운로드

$ repo sync

기존 kernel.org 에서 다운로드 하던 방식에서 변경된 것은

repo 초기화가 주소가 https://android.googlesource.com/platform/manifest

으로 변경된 것입니다.

* 6. 소스 빌드

$make

[알아봅시다] 샵 메일

메일 보내고도 안보냈다 발뺌 못해
'내용증명' 역할 톡톡

[2011년 11월 04일자 18면 기사]

spring + iBatis 연동하기

[출처] http://suicide102.egloos.com/2283394

Spring - iBatis Integration

스프링 - 아이파티스 연동

[출처] http://www.javabeat.net/articles/52-spring-ibatis-integration-1.html

1) Introduction

iBatis is an object-relational mapping tool (ORM) that simplifies access to database. This article details the steps needed for integrating iBatis with Spring. Through such an integration, objects that are specific to iBatis can utilise all the benefits given by Spring's IOC Container. This is not an introductory article for both Spring and iBatis Frameworks. First-time readers are encouraged to read the Introductory article for Spring in javabeat Introduction to Spring Web Framework to know the preliminary concepts related to Spring.

2) Step-by-Step Procedure for Integration

2.1) Introduction

We are going to create a sample table in the MySql Database and going to access the data within it using Spring-iBatis Integration. The required bundles needed to build and run the sample program are listed below.

• Spring Distribution
• MySql Database
• MySql Database Driver

2.2) Creating tables

Create a table called Jsr which contains relevant information for holding information like name, id, description and specification lead for a Java Specification Request (JSR). Issue the following command in the MySql Client command prompt to create the table,

create table Jsr (JsrId varchar(10), JsrName varchar(50), JsrDescription,  varchar(500), SpecLead varchar(100));

2.3) Creating the Java Equivalent

Now let us create a equivalent Java class for the Jsr table. This class, will contain properties that will map to the column names in the Jsr table. Given here is the complete code listing for the Jsr Java class,

Jsr.java

package javabeat.net.articles.spring.ibatis;public class Jsr {    private String id;    private String name;    private String description;    private String specLead;    public String getId()    {        return id;    }    public void setId(String id)    {        this.id = id;    }    public String getName()    {        return name;    }    public void setName(String name)    {        this.name = name;    }    public String getDescription()    {        return description;    }    public void setDescription(String description)    {        this.description = description;    }    public String getSpecLead()    {        return specLead;    }    public void setSpecLead(String specLead)    {        this.specLead = specLead;    }    public String toString()    {        return "Id = " + id + ", Name = " + name +             ", Description = " + description + ", Lead = " + specLead;     }}

2.4) JsrDao Class

Then, we need to get into the client-facing Dao interface design. This is the interface that clients will be depending on, to perform various database operations like selection of rows, insertion, deletion, updating data etc.

JsrDao.java

package javabeat.net.articles.spring.ibatis;import java.util.List;public interface JsrDao {    public List<Jsr> selectAllJsrs();    public Jsr selectJsrById(String jsrID);    public void insertJsr(Jsr insertJsr);    public void deleteJsr(String jsrId);    public void updateJsr(Jsr jsrWithNewValues);}

2.5) iBatis Mapping File

Jsr.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN""http://www.ibatis.com/dtd/sql-map-2.dtd"><sqlMap>    <typeAlias type = "javabeat.net.articles.spring.ibatis.Jsr" alias = "jsr"/>    <resultMap class = "jsr" id = "result">        <result property = "id" column = "JsrId"/>        <result property = "name" column = "JsrName"/>        <result property = "description" column = "JsrDescription"/>        <result property = "specLead" column = "SpecLead"/>    </resultMap>      <select id = "selectAllJsrs" resultMap = "result">        select * from Jsr    </select>    <select id = "selectJsrById" resultMap = "result" parameterClass = "string">        select * from Jsr where JsrId = #value#    </select>    <insert id = "insertJsr" parameterClass="jsr">        insert into Jsr (JsrId, JsrName, JsrDescription, SpecLead) values (#id#, #name#, #description#, #specLead#)    </insert>    <delete id = "deleteJsr" parameterClass="string">        delete from Jsr where JsrId = #value#    </delete>    <update id = "updateJsr" parameterClass="jsr">        update Jsr set JsrName = #name#, JsrDescription = #description#, SpecLead = #specLead#         where JsrId = #id#    </update></sqlMap>

iBatis mapping file contains the mapping information between a Java class and its corresponding table in the database. Not only does it contain this mapping information, but also it contains many definitions for Named Queries. A Named Query is just a query defined with some name so that it can be reused across multiple modules.

The above Xml file starts with an element called 'typeAlias' which is just a short-name for 'javabeat.net.articles.spring.ibatis.Jsr'. Instead of referencing the fully-qualified name of the Jsr class, now it can be shortly referred as 'jsr' in the other sections of the Xml file. Next comes the mapping information specified in the form of 'resultMap' element where the associations between the Java properties for the corresponding column names are made.

Then, the Named Queries section follows. A query called 'selectAllJsrs' has been defined which is actually a select query. The query string value is manifested in the form of 'select * from Jsr'. By having such a query definition, it can be used elsewhere in the Application just by referring the query identifier. Now, let us choose a query definition that illustrates passing parameters to it. The query identifier 'selectJsrById' needs the JsrId as a parameter using which it can filter the number of rows fetched. This can be represented by using the attribute 'parameterClass'. Here 'string' stands for java.lang.String which means that the parameter is of type String. Similarly there are values like 'int', 'float', etc for java.lang.Integer and java.lang.Float respectively. Inside the query definition, we have the following query string,

select * from Jsr where JsrId = #value#

In the above query string, we have defined a new symbol called 'value'. This is the default symbol name for the parameter and since we have only one parameter it would not cause any problem. The expression '#value#' will be substituted with the values specified at the run-time. (Later we will see how the value gets substituted to the above expression).

Now, let us see a query definition that accepts multiple parameters. In the query definition 'insertJsr', we want the jsr id, jsr name, jsr description and spec lead values to get inserted and we have defined the query string as follows,

insert into Jsr (JsrId, JsrName, JsrDescription, SpecLead) values (    #id#, #name#, #description#, #specLead#)

In the query definition, the value of the parameter value is pointing to 'jsr', which means that during run-time the query string will get translated as follows,

insert into Jsr (JsrId, JsrName, JsrDescription, SpecLead) values (    jsr.getId(), jsr.getName(),jsr.getDescription(), jsr.getSpecLead())

2.6) iBatis Configuration File
The Configuration file for iBatis contains references to various mapping files as well as to the dataSource. But in our case, we would not define any dataSource related information in the Configuration file, but instead we will have it in the Spring Configuration file. 
SqlMapConfig.xml 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE sqlMapConfigPUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN""http://www.ibatis.com/dtd/sql-map-config-2.dtd"><sqlMapConfig>    <sqlMap resource="./spring/ibatis/Jsr.xml" /></sqlMapConfig>
2.7) Implementation for JsrDao
We have designed only the client-facing interface in section 2.4. In this section, we shall see the implementation for the same. The following class extends SqlMapClientDaoSupport for getting reference to SqlMapClientTemplate object which simplifies the access to most of the database related operations. 
JsrDaoImpl.java 
package javabeat.net.articles.spring.ibatis;import java.util.List;import org.springframework.orm.ibatis.SqlMapClientTemplate;import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;public class JsrDaoImpl extends SqlMapClientDaoSupport implements JsrDao {    @Override    public List<Jsr> selectAllJsrs()     {        SqlMapClientTemplate template = getSqlMapClientTemplate();        return (List<Jsr>)template.queryForList("selectAllJsrs");    }    @Override    public Jsr selectJsrById(String jsrID)    {        SqlMapClientTemplate template = getSqlMapClientTemplate();        Object objectJsr = template.queryForObject("selectJsrById", jsrID);        return objectJsr instanceof Jsr ? ((Jsr)objectJsr) : null;    }    @Override    public void insertJsr(Jsr insertJsr)    {        SqlMapClientTemplate template = getSqlMapClientTemplate();        template.insert("insertJsr", insertJsr);	    }    @Override    public void deleteJsr(String jsrId)     {        SqlMapClientTemplate template = getSqlMapClientTemplate();        template.delete("deleteJsr", jsrId);    }    @Override    public void updateJsr(Jsr jsrWithNewValues)    {        SqlMapClientTemplate template = getSqlMapClientTemplate();        template.update("updateJsr", jsrWithNewValues);    }}
All the CRUD operations like select(), delete(), insert(), update() will take the named query object which was previously defined in the Configuration file. 
2.8) Spring Configuration File
The Spring configuration that we are going to see has 3 sections. The first section configures a Spring Bean for database access like the data source, the driver class name and username/password information etc. Next we have defined a Factory Bean for reading all the mapping definitions and the named query information in the iBatis Configuration file. This Bean is the 'SqlMapClientFactoryBean' and it references the configuration file 'SqlMapConfig.xml'. The final section is the definition of the JsrDaoImpl bean for client access and it contains references to both the data-source and the sqlMapClientFactoryBean that were declared previously. 
spring-ibatis.xml 
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN""http://www.springframework.org/dtd/spring-beans.dtd">    <beans>        <bean id="dataSource"         class="org.apache.commons.dbcp.BasicDataSource"         destroy-method="close">            <property name="driverClassName">                <value>com.mysql.jdbc.Driver</value>            </property>            <property name="url">                <value>jdbc:mysql://localhost/test</value></property>            <property name="username"><value>root</value></property>            <property name="password"><value>rootPassword</value></property>    </bean>     <bean id="sqlMapClient"     class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">        <property name="configLocation">            <value>./spring/ibatis/SqlMapConfig.xml</value>        </property>    </bean>    <bean id="jsrDao"     class="javabeat.net.articles.spring.ibatis.JsrDaoImpl">        <property name="dataSource"><ref local="dataSource"/></property>        <property name="sqlMapClient"><ref local="sqlMapClient"/></property>    </bean></beans>
2.9) Client Application
JsrClientApplication.java 
package javabeat.net.articles.spring.ibatis;import java.util.List;import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.xml.XmlBeanFactory;import org.springframework.core.io.FileSystemResource;import org.springframework.core.io.Resource;public class JsrClientApplication{    public static void main(String[] args)    {        Resource resource = new FileSystemResource(            "./src/spring/ibatis/spring-ibatis.xml");        BeanFactory beanFactory = new XmlBeanFactory(resource);        JsrDaoImpl jsrDao = (JsrDaoImpl)beanFactory.getBean("jsrDao");        System.out.println("Inserting JSR's");        insertJsrs(jsrDao);        System.out.println("Listing all JSR's");        List<Jsr> allJsrs = jsrDao.selectAllJsrs();        for (Jsr aJsr : allJsrs)        {            System.out.println(aJsr);        }        System.out.println("Selecting a JSR by Id 'JSR002'");        Jsr aJsr = jsrDao.selectJsrById("JSR002");        System.out.println(aJsr);        System.out.println("Updating a JSR");        Jsr fourthJsr = allJsrs.get(3);        fourthJsr.setName("Servlets-Updated");        fourthJsr.setDescription("Java Servlets and JSP-Updated");        fourthJsr.setSpecLead("Belkin-Updated");        jsrDao.updateJsr(fourthJsr);        System.out.println("Deleting a JSR");        jsrDao.deleteJsr("JSR004");    }    static void insertJsrs(JsrDaoImpl jsrDao)    {        Jsr newJsr = createJsr("JSR001", "JMX",             "Java Management Extension", "McManus");        jsrDao.insertJsr(newJsr);        newJsr = createJsr("JSR002", "XML",             "XML Parsing Spec", "Rajiv");        jsrDao.insertJsr(newJsr);        newJsr = createJsr("JSR003", "JDO",             "Java Data Objects", "Russell");        jsrDao.insertJsr(newJsr);        newJsr = createJsr("JSR004", "Servlets",             "Java Servlets and JSP", "Belkin");        jsrDao.insertJsr(newJsr);    }    static Jsr createJsr(String id, String name, String description, String specLead)    {        Jsr newJsr = new Jsr();        newJsr.setId(id);        newJsr.setName(name);        newJsr.setDescription(description);        newJsr.setSpecLead(specLead);        return newJsr;    }}
The Client Application in the above case gets a reference to the JsrDao object defined in the Spring Configuration file and makes use of it by testing the various available CRUD operations. 
3) Conclusion
This article provided the various introductory details for integrating iBatis with Spring Framework. The procedure for this integration has been explained in depth. This would help the readers to integrate iBatis with Spring framework and thereby allow the objects specific to iBatis to make optimum use of the features available in the Spring framework. 

Spring 3 MVC Hello World Example

[출처] http://www.roseindia.net/tutorial/spring/spring3/web/spring-3-mvc-hello-world.html

Getting stated with the Spring 3 MVC by developing first Hello World MVC example. This is the first example of writing first example in Spring MVC. After completing the tutorial you will be able to start developing small applications using Spring MVC.

In this section we will create a new project in Eclipse IDE and will name it "Spring MVC Hello World" application. We are using Spring 3 libraries in the application. You can download the latest Spring 3 framework fromhttp://www.eclipse.org/downloads/.

Let's start application "Spring MVC Hello World " example

Step 1:

Before we start Spring 3.0 at least requires JDK 5. So, make sure you have JDK 5 or above. Open dos prompt if you are using windows and type java -version. This will display the version of Java installed on your machine as shown below:

If you don't know how to install Java read it athttp://www.roseindia.net/java/index.shtml

Step 2:

Download Eclipse IDE from Eclipse download site athttp://www.eclipse.org/downloads/. find the eclipse.exe in the extracted folder and double click eclipse.exe.

Step 3:

Spring 3.0 MVC JAR files:. Following are the list of JAR files required -

• commons-logging-1.1.1.jar
• jstl-1.2.jar
• spring-asm-3.0.3.RELEASE.jar
• spring-beans-3.0.3.RELEASE.jar
• spring-context-3.0.3.RELEASE.jar
• spring-core-3.0.3.RELEASE.jar
• spring-expression-3.0.3.RELEASE.jar
• spring-web-3.0.3.RELEASE.jar
• spring-webmvc-3.0.3.RELEASE.jar

Step 4:

Step 5:

Now copy all jar files and put in WebContent->WEB-INF > lib folder. display as

Step 6:

now src->New->other->Select Class and press Next

After press Next Inter Package name "net.roseindia.controllers" and Controller class name "HelloWorldController" and press Finish . after modify "HelloWorldController" as

Step 7:

Now select WebContent->WEB-INF->New ->select Folder and Inter Folder name "views" and press Finish. Now create "helloworld.jsp" under WEB-INF->views.

File: WEB-INF/views/helloworld.jsp

Step 8:

Now create "index.jsp" under WebContent->index.jsp

File:WebContent/index.jsp

Step 9:

Now modify web.xml under WebContent/WEB-INF/web.xml

Step 9:

Step 10:

After we Add server in project . right click project -> New->server-> select server

Now press Next

Now press Add and set server runtime environment. if exists in local tomcat then press "Browse" and select Tomcat server path otherwise press "Download and Install" .

Now press Finish and press Next.

Now press Add All>> and after press Finish .

Step 11:

Now Run the Project , Right click project ->Run As->Run on Server((Shortcut: Alt+Shift+X, R))

After click "Hello World" Link

Download Source Code

Click here to download source code

Related Tags for Spring 3 MVC hello world, Spring 3.0 Web MVC Example:

Spring DI(Dependency Injection)와 AOP(Aspect Oriented Programming) 맛보기

[출처] http://suecream.tistory.com/entry/Spring-DIDependency-Injection%EC%99%80-AOPAspect-Oriented-Programming-%EB%A7%9B%EB%B3%B4%EA%B8%B0

Spring

Spring이란 무엇인가?엔터프라이즈 어플리케이션에서 필요로 하는 기능을 제공하는 프레임 워크이다.

J2EE에서 제공하는 다양한 기능 뿐만 아니라, DI, AOP와 같은 기능도 지원하고 있다.

특징

1. 스프링은 경량 컨테이너 이다.

스프링은 자바 객체를 담고 있는 컨테이너이다. 스프링은 이들 자바 객체의 생성, 소멸과 같은 라이프 사이클을 관리하며, 스프링으로부터 필요한 객체를 가져와 사용할 수 있다.

2. 스프링은 DI패턴을 지원한다.

스프링은 설정 파일을 통해서 객체간의 의존 관계를 설정할 수 있도록 하고 있다. 따라서 객체는 직접 의존하고 있는 객체를 생성하거나 검색할 필요가 없다.

3. 스프링은 AOP를 지원한다.

스프링은 자체적으로 AOP를 지원하고 있기 때문에 트랜잭션이나 로깅 보안과 같이 여러 모듈에서 공통적으로 필요로 하지만 실제 모듈의 핵심이 아닌 기능들을 분리해서 각 모듈에 적용할 수있다.

4. 스프링은 POJO를 지원한다.

스프링 컨테이너에 저장되는 자바 객체는 특정한 인터페이스를 구현하거나, 클래스를 상속받지 않아도 된다. 따라서 기존에 작성한 코드를 수정할 필요없이 스프링에서 사용할 수 있다.

5. 트랜잭션 처리를 위한 일관된 방법을 제공한다.

JDBC를 사용하든, JTA를 사용하든 또는 컨테이너가 제공하는 트랜잭션을 사용하든, 설정 파일을 통해 트랜잭션 관련 정보를 입력하기 때문에, 트랜잭션 구현에 상관없이 동일한 코드를 여러 환경에서 사용할 수 있다.

6. 영속성과 관련된 다양한 API를 제공한다.

스프링은 JDBC를 비롯하여 iBatis, 하이버네이트등 데이터베이스 처리와 관련하여 널리 사용되는 라이브러리와의 연동을 지원하고 있다.

7. 다양한 API에 대한 연동을 지원한다.

스프링은 JMS, 메일, 스케쥴링등 엔터프라이즈 어플리케이션을 개발하는데 필요한 다양한 API를 설정 파일을 통해서 손쉽게 사용할 수 있도록 하고 있다.

8. 자체적으로 MVC프레임워크를 제공한다.

때문에 스프링만 사용하면 MVC기반의 웹어플리케이션을 어렵지 않게 개발할수 있다.

Spring Framework의 설치와 모듈 구성

1. http://Springframework.org/download 에서 최신 버전을 다운 받는다 (현재: 2.5.6)

2. 압축을 푼다

dist폴더 : 스프링 Jar파일을 포함하고 있는 폴더

lib폴더 : 스프링을 사용하는 필요한 모든 외부 라이브러리를 포함하고 있는 폴더

docs폴더 : 스프링 레퍼런스 및 API Javadoc를 포함하고 있는 폴더

DI(Dependency Injection과 Spring Framework)

객체사이의 의존 관계를 객체끼리 직접하는것이 아니라, 외부 조립기가 수행한다는 개념

의존 관계 처리 방법 3가지

1. 코드에 직접 의존 객체 명시 AbstractDAO dao = new LoginDAO();

2. Factory 패턴이나 JNDI등을 사용해 클래스를 명시 (EJB같은곳에서 사용)

AbstractDAO dao = DAOFactory.create();

3. 외부 조립기를 사용 (Dependency Injection - DI 패턴 ~Inversion of Control)

외부 조립기를 사용하는 이 방법은 불필요한 의존 관계를 없애주는 좋은 방법이다.

DI패턴을 이용하면 직접적으로 객체에 의지 하지 않고 인터페이스에만 의존하게 된다.

DI패턴 적용 두가지 방법

1. 생성자 방식을 이용하여 설정

2. 설정 메소드를 이용하여 설정 (setter)

2. 스프링 설정 파일을 이용하여 의존 관계 설정(applicationContext.xml))

<bean name="writeArticleService"

class="kame.spring.chap01.WriteArticleServiceImpl">

<constructor-arg>

<ref bean="articleDao" />

</constructor-arg>

</bean>

<bean name="articleDao"

class="kame.spring.chap01.MysqlArticleDao">

</bean>

의 의미는

MySqlArticleDao articleDao = new MyArticleDao();

WriteArticleServiceImpl writeArticleService = new WriteArticleServiceImpl (articleDao);

위와 같은 xml 선언을 통해 WriteArticleServiceImpl객체와 MySqlArticleDao객체 사이의 의존 관계를 설정하였다.

//이렇게 설정하면 스프링 컨테이너로 부터 빈 객체를 가져와서 사용 할 수 있다.

Resource resource = new ClassPathResource("applicationContext.xml");

BeanFactory beanFactory = new XmlBeanFactory(resource);

WriteArticleService articleService =

(WriteArticleService) beanFactory.getBean("writeArticleService");

articleService.write(new Article);

이것을 제어 역행이라고 하는데, 스프링 프레임 워크의 핵심이다.

의존성을 띄는 객체를 내가 생성하는 것이 아니라,
내가 주입 받는것이다. 따라서 내가 원래 그 객체를 생성하고 살리고 하는 주제 제어자 였는데,

Dependency Injection에 의하여 내가 주입을 받는 대상자가 되어 버렷다.

따라서 저어가 역행하게 된것이다.

결합된 코드 즉, 밀접하게 연관이 된 코드는 테스트하고 재 사용할 시 어려우며 이해하기도 어렵다. 때문에 결합도를 낮추어서 의존하는 객체들 간 협업을 조정하는 책임이 객체 자체로부터 분리되어 나간 것을 말한다.

스피링에서의 AOP

1. POJO기반 AOP적용

기존에 우리는 특정 클래스(객체)를 공통적으로 사용할 필요성이 있을 때

특히 보안, 트랜잭션, 공통 기능(Common Class, Common Method같은 것들)을 여러 개의 서로 다른 객체들에서 접근하여 사용하려 할 때 일일이 생성하고 메소드를 불러서 써야 했다.

예를 들어 사용자가 입력한(이름, 주소, 학력, 각종 개인정보에 대하여 각기 다른 필드를 통해서 입력을 받을때) String객체를 암호화 하는 프로세스를 가진 간단한 프로그램이 있다고 가정할때, 각각의 정보들에 대하여 일일이 암호화하는(동일한 암호화 알고리즘으로..) 프로세스를 거쳐야 한다 (적절한 예인지는 잘 모르겠다;;) 생성된 객체에 대하여 일일이 메소드에 해당 값을 집어 넣은후 받아 와야 하는 번거로움이 생기며, 복잡한 의존성을 불필요하게 가지게 된다. 만에 하나 갑작스러운 요구 사항의 변경으로 필드를 하나 추가하거나, 필드를 삭제하게 될 때 해당 메소드를 부르는 작업을 추가 하거나 삭제 해야 한다. (깜빡하고 삭제하지 않으면 당연히 엑셉션이 발생하게 된다)

이는 매우 비 효율적인 것 임에 틀림없다.

때문에 나온 것이 AOP라는 기법이다.

AOP(Aspect Oriented Programming)란 공통 관심사항에 대하여 발생하는 복잡성과 코드 중복을 해소해 주는 프로그래밍 기법이다.

여기서 중요한 개념이 Aspect인데, 이 Aspect가 공통 모듈을 로직을 구현할 클래스에 적용된다.

(써놓고 보니 매우 난해하다;;;)

한마디로 말해 공통 관심사에 관해서 공통 관심사를 사용할 객체들이 직접 공통 관심사(공통 객체)를 생성 접근하는 것은 프로그램의 복잡도를 증가 시키고, 코드를 중복 시키고 결합도를 높여 객체지향적이지 못해지는 요인으로 작용하므로, 그렇게 하지 말고( 공통 관심사를 사용할 놈들이 직접 생성해서 지지고 볶고 하지 말고) 외부에서 따로 이쁘게 처리하자~! 이말이다.

예를 보자

<공통 관심사 클래스> - 아래의 클래스가 우리가 공통 관심사로서 사용할 클래스 이다.

public class LoggingAspect {

private Log log = LogFactory.getLog(getClass());

public Object logging(ProceedingJoinPoint joinPoint) throws Throwable {

log.info("기록시작);

StopWatch stopWatch = new StopWatch();

try {

stopWatch.start();

Object retValue = joinPoint.proceed();

return retValue;

} catch (Throwable e) {

throw e;

} finally {

stopWatch.stop();

log.info("기록종료);

log.info(joinPoint.getSignature().getName() + "메소드실행시간: "

+ stopWatch.getTotalTimeMillis());

}

}

}

그렇다면 이놈을 일일이 사용할 다른 여러 객체들에서 접근하지 말고 어떻게 쓸까?

<bean id="logging" class="kame.spring.chap01.LoggingAspect" />

<aop:config>

<aop:pointcut id="servicePointcut" expression="execution(* *..*Service.*(..))" />

<aop:aspect id="loggingAspect" ref="logging">

<aop:around pointcut-ref="servicePointcut" method="logging" />

</aop:aspect>

</aop:config>

이렇게 하면, expression="execution(* *..*Service.*(..))" />에 의해서 Service로 끝나는 인터페이스를 구현한 객체들에 대하여 우리의 공통 관심사 객체가 적용이 되게 된다.

음 . . 보다 자세한 내용은 좀 더 공부 해보아야 겠다 . 일단 DI와 AOP맛보기는 끝~!

(출처 및 인용 : 최범균님의 Spring 2.5 Programming, Spring in Action이 참 이해하기 쉽게 잘되어 있다 두책을 번갈아 보면서 공부하면 매우 효율적이다. 그리고 나는 가메 출판사에서 나오는 관련 전공 서적들에 항상 매력을 느낀다 . . Struts때도 그랫고 . . EJB3.0도 그렇고 . .)

[JSP/JAVA] 최상위, 파일 경로 알아내기