Docstoc

Spring+Tutorial

Document Sample
Spring+Tutorial Powered By Docstoc
					                              SPRING TUTORIAL
I. Giới thiệu về Spring:

Spring là một application framework mã nguồn mở, được giới thiệu vào năm 2002. Rod
Johnson đã đưa ra ý tưởng này từ kinh nghiệm làm việc với kiến trúc J2EE.

Ông ta đã viết cuốn sách với tiêu đề: “J2EE Develoment without using EJB” để giới thiệu
khái niệm trình chứa hạng nhẹ (lightweight container). Với lý luận: EJB thì có giá trị của nó,
nhưng không phải lúc nào cũng cần thiết và phù hợp cho tất cả các ứng dụng.

Như Hibernate chống lại CMP về nguyên lý cơ bản của kỹ thuật ORM, Spring chống lại EJB
vì sự phức tạp và không phù hợp cho các unit test. Thay vì EJB, Spring sử dụng Java bean,
với một vài sự thay đổi để thu được tất cả các thuận lợi mà môi trường EJB đưa ra. Do đó
Spring là một sự lựa chọn khác so với EJB.

Spring không phải là một kỹ thuật persistence nhưng nó cho phép tích hợp với các kỹ thuật
khác. EJB thì tập trung vào kỹ thuật persistence và bây giờ nó đã cộng tác với Hibernate, một
ORM tốt nhất ngày nay. Nó đang dự định cộng tác với một kỹ thuật ORM tốt khác là JDO
(cung cấp cho Object Database).

Trong Spring, chúng ta có thể sử dụng Java Bean để rút trích các thứ mà lúc trước chỉ có thể
với EJB. Mục tiêu chính của Spring là đơn giản việc phát triển J2EE và testing.

EJB được xuất hiện vào 1988 và là một chuẩn, đặc tả trong thế giới Enterprise. Mặc dù có
một số kỹ thuật Java gần đây, nhưng không có kỹ thuật nào đáng kể so với EJB về mặc tổng
các đặc tính của nó.

Theo Rod Johnson thì EJB không phức tạp nhưng nó cố gắng cung cấp cách giải quyết cho
các vấn đề phức tạp. EJB được phát triển chính cho các giao dịch, đối tượng được phân phát
ở trên máy khác. Nhưng một số enterprise project không có mức độ phức tạp và vẫn sử dụng
EJB và thậm chí các ứng dụng đơn giản trở nên phức tạp. Trong trường hợp này thì Spring là
một sự chọn lựa.

Từ lúc Spring hỗ trợ các dịch vụ ở mức enterprise, thì nó tuyên bố là một sự lựa chọn khác
đối với EJB.

Thuận lợi của EJB:
  a) Transaction Management
  b) Declarative Transaction support
  c) Persistence ( CMP & BMP)
  d) Declarative Security
  e) Distributed Computing (Container managed RPC)

Spring không cố gắng làm mọi thứ nhưng nó hỗ trợ những kỹ thuật tốt nhất cho mỗi yêu
cầu.Thay vì CMP & BMP, nó hỗ trợ một vài kỹ thuật persistence khác như JDO, Hiberbate
và OJB. Các ORM tool này thì có nhiều khả năng cài đặt hơn CMP. Để đơn giản coding
JDBC, có một tool là iBatis và Spring cũng hỗ trợ nó.

Spring sử dụng Acegi, một security framework mã nguồn mở và cung cấp để khai báo
security thông qua cấu hình Spring hoặc class metadata, trong khi EJB khai báo security
được cấu hình thông qua mô tả demployment. Spring cung cấp proxying cho RMI (kỹ thuật
remoting đặc biệt như Burlap) JAX-RPC & web-service, trong khi EJB cung cấp lời gọi
phương thức ở xa được quản lý bởi container.

Spring có thể cung cấp khai báo transaction như EJB. Hơn nữa, Spring còn cung cấp khai
báo thủ tục rollback cho các phương thức và exception.

Do đó, trong khi EJB thì cứng và cố gắng làm mọi thứ, một vài công việc tốt nhưng một số
thì không. Spring chỉ sử dụng Java Bean và thông qua một số kỹ thuật đặc biệt để cung cấp
nhiều chức năng như EJB, bằng cách tích hợp với một số kỹ thuật open source khác.

Do đó, nó cung cấp một vài thuận lợi hơn EJB như:
        a) Testing dễ dàng hơn - không cần khởi động EJB container để test.
        b) Spring dựa vào quy ước của chuẩn Java Bean, nên programmer dễ dàng làm việc
với nó.
        c) Nó sử dụng AOP (Aspect-Oriented Programming), mô hình hữu ích để bổ sung
vào OOP truyền thống và bảo toàn tính nguyên vẹn của OOP.
        d) Nó thì uyển chuyển.

Mục đích của Spring là trở thành một application framework. Các framework phổ biến khác
như Struts, Tapestry, JSF,... là các framework tốt cho tầng web nhưng khi chúng ta sử dụng
các framework này, chúng ta phải cung cấp thêm framework khác để giải quyết tầng
enterprise mà tích hợp tốt với các framework này. Spring làm giảm bớt vấn đề này bằng cách
cung cấp một framework toàn diện bao gồm:
            Core bean container,
            MVC framework,
            AOP integration framework,
            JDBC integration framework,
            EJB integration framework.

Nó cũng cung cấp module tích hợp với O/R tool như Hibernate và JDO. Do đó Spring
framework có thể được xem như một kiến trúc chứa 7 module. Chức năng của mỗi thành
phần như sau:

   1. Core Container:

   Core container cung cấp chức năng cơ bản của Spring. Thành phần chính của nó là Bean
Factory, một cài đặt của Factory pattern. BeanFactory áp dụng IoC pattern để đặc tả sự phụ
thuộc từ code của ứng dụng.

   2. Spring Context/Application Context:
    Spring context là một file cấu hình để cung cấp thông tin ngữ cảnh của Spring. Spring
context cung cấp các service như JNDI access, EJB integration, e-mail, internalization,
validation, và scheduling functionality.

   3. Spring AOP (Aspect-Oriented):

    Spring AOP module tích hợp chức năng lập trình hướng khía cạnh vào Spring framework
thông qua cấu hình của nó. Spring AOP module cung cấp các dịch vụ quản lý giao dịch cho
các đối tượng trong bất kỳ ứng dụng nào sử dụng Spring. Với Spring AOP chúng ta có thể
tích hợp declarative transaction management vào trong ứng dụng mà không cần dựa vào EJB
component.

    Spring AOP module cũng đưa lập trình metadata vào trong Spring. Sử dụng cái này
chúng ta có thể thêm annotation vào source code để hướng dẫn Spring nơi và làm thế nào để
liên hệ với aspect.

   4. Spring DAO:

    Tầng JDBC và DAO đưa ra một cây phân cấp exception để quản lý kết nối đến database,
điều khiển exception và thông báo lỗi được ném bởi vendor của database. Tầng exception
đơn giản điều khiển lỗi và giảm khối lượng code mà chúng ta cần viết như mở và đóng kết
nối. Module này cũng cung cấp các dịch vụ quản lý giao dịch cho các đối tượng trong ứng
dụng Spring.

   5. Spring ORM:

   Spring có thể tích hợp với một vài ORM framework để cung cấp Object Relation tool bao
gồm: JDO, Hibernate, OJB và iBatis SQL Maps.

   6. Spring Web module:

    Nằm trên application context module, cung cấp context cho các ứng dụng web. Spring
cũng hỗ trợ tích hợp với Struts, JSF và Webwork. Web module cũng làm giảm bớt các công
việc điều khiển nhiều request và gắn các tham số của request vào các đối tượng domain.

   7. Spring MVC Framework:

   MVC Framework thì cài đặt đầy đủ đặc tính của MVC pattern để xây dựng các ứng dụng
Web. MVC framework thì cấu hình thông qua giao diện và chứa được một số kỹ thuật view
bao gồm: JSP, Velocity, Tiles và generation of PDF và Excel file.

   Ví dụ:

   Có một số kỹ thuật tuyệt vời cho tầng web như: Spring MVC framework, Struts, JSF,
WebWork, JSP, Tapestry, FreeMarker,...Developer sẽ bị lúng túng đối chiếu những điểm
mạnh và xấu của tất cả chúng. Mỗi khi họ chọn một kỹ thuật và bắt đầu cài đặt, thì sau đó
nếu họ muốn thay đổi một kỹ thuật khác thì rất khó. Nhưng Spring đưa ra các module cho tất
cả các kỹ thuật trên, và rất đơn giản để thay đổi file cấu hình.

    Với phương pháp này, nó có khả năng cho cả team thử và test các tất cả các hình thức
trên và xem ảnh hưởng cùng tốc độ trước khi quyết định chọn lựa.

   JSP là một view template mặc định. "InternalResouceViewResolver" có thể được sử
dụng cho mục đích này.

II. Các khái niệm chính của Spring:

Các khái niệm chính của Spring là: IoC và Aspect Orient Programming. Spring dựa vào
Depenecy injection của IoC. Chúng ta không trực tiếp kết nối các component và service lại
với nhau trong code mà thông qua file cấu hình. Một container thì chịu trách nhiệm móc nối
nó. Khái niệm này thì tương tự với Declarative Management.

   1. Dependency Injection:

    Depedency injection là một pattern chịu trách nhiệm tạo đối tượng và các liên kết giữa
các đối tượng bị loại bỏ ra khỏi các đối tượng và chuyển đến cho factory quản lý.

   Các đối tượng của ứng dụng không chịu trách nhiệm tìm kiếm các resource mà chúng
phụ thuộc. Và vì thế nên sự phụ thuộc được đảo ngược vào trong các đối tượng.

    Theo phương pháp này, các đối tượng có thể được rút trích thông qua Setter Injection
(các thuộc tính của Java-Beans) hoặc Constructor Injection (tham số của constructor). Mỗi
phương thức có thuận lợi và bất lợi riêng.

    Bình thường trong Java bean, chúng ta sử dụng phương thức setter và getter để thiết lập
và lấy giá trị của thuộc tính như sau:

   public class namebean {
      String name;
      public void setName(String a)
        name = a;
      }
      public String getName()
      {
        return name;
      }
   }

   Chúng ta sẽ tạo một thể hiện của bean "namebean" (gọi là bean1) và thiết lập thuộc tính:
bean1.setName("Tom"). Còn trong setter injection, chúng ta thiết lập thuộc tính "name" trong
subelement <property> của thẻ <bean> trong file cấu hình Spring như sau:

   <bean id="bean1" class="namebean">
     <property name="name" >
       <value>Tom</value>
     </property>
   </bean>

   Subelement <value> thiết lập thuộc tính "name" bằng cách gọi phương thức set như sau:
   setName("Tom"); => tiến trình này được gọi là setter injection.

   Ví dụ về constructor injection, chúng ta sử dụng constructor với một tham số:

   public class namebean {
      String name;
      public namebean(String a)
      {
        name = a;
      }
   }

    Chúng ta sẽ thiết lập thuộc tính "name" trong khi tạo thể hiện của bean "namebean" như
sau: namebean bean1 = new namebean("Tom");

   Ở đây chúng ta sử dụng element <constructor-arg> để thiết lập thuộc tính sử dụng
constructor injection như sau:

   <bean id="bean1" class="namebean">
     <constructor-arg>
       <value>My Bean Value</value>
     </constructor-arg>
   </bean>

   Để thiết lập các thuộc tính tham chiếu đến bean khác - <ref>, subelement <property>
được sử dụng như sau:

   <bean id="bean1" class="bean1impl">
     <property name="game">
       <ref bean="bean2"/>
     </property>
   </bean>
   <bean id="bean2" class="bean2impl" />

   2. Aspect-oriented Programming:

    Kỹ thuật lập trình đưa ra cách phân chia các yêu cầu của hệ thống. Hệ thống được phân ra
thành một vài component đảm trách một chức năng xác định. Bên cạnh các chức năng cơ bản
thì các dịch vụ (yêu cầu hệ thống) như logging, transaction management, security...phải có
trong chương trình. Các dịch vụ hệ thống này được gọi là 'cross-cutting concern' - nghĩa là
chúng cắt chéo qua nhiều component trong hệ thống. AOP có khả năng module hóa các
service này và sau đó cung cấp đến các component và chúng ta có thể tập trung vào yêu cầu
chính (core concern). Trong Spring, lát cắt (aspect) được cắm vào trong các đối tượng của
XML file như các JavaBean. Tiến trình này gọi là sự đan xen (weaving).

    Container là khái niệm chính của Spring. Để quản lý vòng đời và cấu hình các đối tượng
của ứng dụng. Chúng ta có thể cấu hình mỗi bean nên được tạo như thế nào hoặc làm thế nào
để tạo một instance của bean hoặc làm thế nào kết hợp chúng lại. Spring không sử dụng các
EJB container hạnh nặng. Spring có 2 container phân biệt: Bean Factory được định nghĩa bởi
org.springframework. beans.factory.BeanFactory là một container đơn giản nhất, cung cấp hỗ
trợ dependency injection. Application context được định nghĩa bởi
org.springframework.context.ApplicationContext, cung cấp các service của application
framework.

   2.1. Bean Factory:

    Bean factory thì cài đặt factory design pattern và chức năng của nó là tạo và phân phát
các bean. Bean factory biết về nhiều đối tượng trong ứng dụng, nó có thể tạo mối kết hợp cho
các đối tượng khi chúng được khởi tạo. Điều này sẽ giảm bớt gánh nặng cho bean và client.

    Có một vài cài đặt của BeanFactory. Một cái hữu ích nhất là
org.springframework.beans.factory.xml.XmlBeanFactory. Nó sẽ load các bean dựa vào định
nghĩa trong XML file. Để tạo một thể hiện của XmlBeanFactory, hãy chuyển vào constuctor
của nó một InputStream. Resource này sẽ cung cấp XML cho factory.

    BeanFactory factory = new XmlBeanFactory(new FileInputStream("myBean.xml"));
=> dòng này bảo bean factory đọc định nghĩa bean từ XML file. Định nghĩa bean bao gồm
mô tả bean và các thuộc tính của nó. Nhưng bean factory vẫn chưa khởi tạo nó. Để rút trích
một bean từ BeanFactory, hãy gọi phương thức getBean(). Khi phương thức getBean() được
gọi, factory sẽ khởi tạo bean và bắt đầu thiết lập các thuộc tính của nó sử dụng depedency
injection.
    myBena bean1 = (myBean)factory.getBean("myBean");

   2.2. Application Context:

   Trong khi Bean Factory được sử dụng cho các ứng dụng đơn giản, thì Application
Context là một container nâng cao của Spring. Giống như BeanFactory, nó có thể được sử
dụng để load các định nghĩa bean, gắn các bean với nhau và phân phát các bean theo yêu cầu.

   Nó cũng cung cấp:
      1) giải quyết text message, bao gồm hỗ trợ internationlization.
      2) cách chung để load file resource.
      3) các sự kiện để bean được đăng ký như các trình lắng nghe.

   Có 3 cách sử dụng cài đặt Application Context:
    1) ClassPathXmlApplicationContext: Nó load định nghĩa context từ XML file được đặt
trong classpath, xem các định nghĩa context như các tài nguyên của classpath. Application
context thì được load từ classpath của ứng dụng như sau:

   ApplicationContext     context = new ClassPathXmlApplicationContext("bean.xml");

    2) FileSystemXmlApplicationContext: Nó load định nghĩa context từ XML file trong từ
hệ thống file. Application Context được load từ hệ thống file như sau:

   ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml");

   3) XmlWebApplicationContext: Nó sẽ load các định nghĩa context từ XML file trong
ứng dụng web.

   Spring thì nhẹ về cả kích cỡ và chi phí. Toàn bộ framework có thể được phân phát trong
JAR file chỉ hơn 1.7MB. Chi phí được yêu cầu bởi Spring thì không đáng kể. Và Spring
không ràng buộc, ví dụ: các đối tượng trong ứng dụng Spring không phụ thuộc vào các class
của Spring.

III. Release info:

Spring framework được download ở trang http://www.springframework.org. Trên đó có 2
file zip: một file có dependencies, một file thì không. Spring framework với dependencies thì
lớn hơn và chứa tất cả thư viện phụ thuộc.

Nội dung của phân phối "-with-dependencies" (~60 MB):
   * "dist" chứa các file jar của bảng phân phối và một file nén chứa tất cả source code.
   * "docs" chứa tài liệu có định dạnh PDF, HTML và javadocs.
   * "lib" chứa tất cả thư viện cần để xây dựng framework hoặc chạy các ví dụ.
   * "src" chứa các file Java source của framework.
   * "mock" chứa các file Java source cho mock và test.
   * "test" chứa file java cho bộ test của Spring.
   * "tiger/src" chứa các file JDK-1.5-specific Java source cho framework.
   * "tiger/test" chứa các file JDK-1.5-specific Java source cho bộ test của Spring.
   * "aspectj/src" chứa tất cả file AspectJ-specific source cho framework
   * "aspectj/test" chứa tất cả file AspectJ-specific source cho cho bộ test của Spring.
   * "samples" chứa các ứng dụng demo và chương trình giới thiệu.

IV. Spring Application:

Các bước tạo ứng dụng sử dụng Spring:

   1. Một interface định nghĩa các chức năng.
   2. Một implementation chứa các thuộc tính, các phương thức settter và getter.
   3. Một file XML gọi là file cấu hình Spring.
   4. Chương trình client sử dụng chức năng trên.
1.
     public interface Hello {
             public String sayHello(String s);
     }

2.
     public class HelloImpl implements Hello{

            private String greeting;
            /**
             * Class constructor
             * @param s
             */
            public HelloImpl(){

            }
            public HelloImpl(String s){
                    greeting = s;
            }
            /**
             * function
             */
            public String sayHello(String s) {
                    return greeting + s;
            }
            /**
             * @return Returns the greeting.
             */
            public String getGreeting() {
                    return greeting;
            }
            /**
             * @param greeting The greeting to set.
             */
            public void setGreeting(String greeting) {
                    this.greeting = greeting;
            }
     }

3.
     <?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="hello" class="HelloImpl">
                 <property name="greeting">
                       <value>Good Morning!</value>
                 </property>
           </bean>
       </beans>

4.
       import org.springframework.beans.factory.BeanFactory;
       import org.springframework.beans.factory.xml.XmlBeanFactory;
       import org.springframework.core.io.ClassPathResource;

       public class HelloClient {

              /**
               * @param args
               */
              public static void main(String[] args) {
                      try {
                              ClassPathResource resource = new
       ClassPathResource("hello.xml");
                              BeanFactory factory = new XmlBeanFactory(resource);
                              HelloImpl bean = (HelloImpl) factory.getBean("hello");
                              String hello = bean.sayHello("Trinh");
                              System.out.println(hello);
                      } catch (Exception e) {
                              e.printStackTrace();
                      }
              }
       }

Chạy ứng dụng sẽ kết xuất như sau:
2007/01/12 13:43:16 org.springframework.core.CollectionFactory <clinit>
 報
情 : JDK 1.4+ collections available
2007/01/12 13:43:17
org.springframework.beans.factory.xml.XmlBeanDefinitionReader
loadBeanDefinitions
 報
情 : Loading XML bean definitions from class path resource [hello.xml]
Good Morning!Trinh

Ở đây, HelloImpl cài đặt giao tiếp Hello. Mặc dù không cần thiết phải dấu cài đặt phía sau
một giao tiếp. HelloImpl có một thuộc tính greeting. Thuộc tính này có thể được thiết lập
theo 2 cách: bằng phương thức setter hoặc bằng constructor. File hello.xml khai báo một thể
hiện của HelloImpl trong container của Spring và cấu hình giá trị của thuộc tính greeting là
"Good Morning!".

Root của file hello.xml là <beans> element - là root element của bất kỳ file cấu hình nào của
Spring. Element <bean> được sử dụng để bảo Spring container về lớp và nó nên được cấu
hình như thế nào. Ở đây, thuộc tính id là tên của interface và thuộc tính class xác định tên lớp
đầy đủ của bean.

Trong <element> bean, element <property> được sử dụng để thiết lập thuộc tính, trong
trường hợp này là thuộc tính greeting. Sử dụng <property>, chúng ta nói với Spring container
gọi phương thức setGreeting(). Giá trị của greeting được định nghĩa trong element <value>.
Container sẽ khởi tạo HelloImpl dựa vào định nghĩa XML như sau:

HelloImpl hello = new HelloImpl ();
hello.setGreeting("Good Morning!...");

Tương tự, thuộc tính greeting có thể được thiết lập thông qua constructor có 1 tham số của
HelloImpl như sau:

<bean id="hello" class=" HelloImpl">
<constructor-arg>
   <value>Good Morning!...</value>
</constructor-arg>
</bean>

Bây giờ thì container khởi tạo HelloImpl dựa vào định nghĩa XML như sau:
HelloImpl hello = new HelloImpl("Good Morning...");

Ở chương trình client, lớp BeanFactory được sử dụng là Spring container. Sau đó phương
thức getBean() được gọi để lấy tham chiếu đến bean "hello". Với tham chiếu này thì phương
thức sayHello() được gọi.

Bước kế tiếp chúng ta sẽ xem làm thế nào để chạy chương trình này như một servlet. Đầu
tiên copy spring.jar đến thư mục common\lib của Tomcat và khởi động tomcat server. Sau
khi thiết lập classpath, tạo file HelloServlet.java như sau:

HelloServlet.java
      import java.io.IOException;
      import java.io.PrintWriter;
      import javax.servlet.ServletException;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import org.springframework.beans.factory.BeanFactory;
      import org.springframework.beans.factory.xml.XmlBeanFactory;
      import org.springframework.core.io.ClassPathResource;

       public class HelloServlet extends HttpServlet{
               /**
                *
                */
               private static final long serialVersionUID = 1L;
               @Override
               protected void doPost(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
                       String name = request.getParameter("userName");
                       response.setContentType("text/html");
                      ClassPathResource resource = new ClassPathResource("hello.xml");
                      BeanFactory factory = new XmlBeanFactory(resource);
                      Hello bean = (Hello) factory.getBean("hello");
                      PrintWriter out = response.getWriter();
                      out.write(bean.sayHello(name));
                }

       }
index.html
       <html>
       <body>
            <form method="post"
action="http://localhost:8080/springservlet/hello">
                  <input type="text" name="userName"/>
                  <input type="submit" value="sayHello"/>
            </form>
      </body>
      </html>
web.xml
       <?xml version="1.0" encoding="UTF-8"?>
       <web-app id="WebApp_ID" version="2.4"
       xmlns="http://java.sun.com/xml/ns/j2ee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
       http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
             <display-name>springservlet</display-name>
             <servlet>
                   <servlet-name>hello</servlet-name>
                   <servlet-class>HelloServlet</servlet-class>
                   <load-on-startup>1</load-on-startup>
             </servlet>
             <servlet-mapping>
                   <servlet-name>hello</servlet-name>
                   <url-pattern>/hello</url-pattern>
             </servlet-mapping>
             <welcome-file-list>
                   <welcome-file>index.html</welcome-file>
             </welcome-file-list>
       </web-app>

Bây giờ chúng ta sẽ vào tiến trình chính của bất kỳ ứng dụng enterprise nào: data persistence.
Spring có framework data access riêng của nó. Spring chia phần cố định và tùy biến của tiến
trình data access thành hai lớp phân biệt: Template và Callback. Template quản lý phần cố
định của framework như data connection, quản lý tài nguyên, điều khiển giao dịch...Trong
khi Callback định nghĩa các thứ được xác định trong ứng dụng như tạo statement, móc nối
tham số...Lớp Template của Spring là JdbcTemplate. Một data source phải được cung cấp
bên trong JdbcTemplate.

Một ví dụ về kết nối CSDL sử dụng JdbcTemplate như sau. Ở đây chúng ta sử dụng CSDL
MySQL. Sau khi tạo bảng user(name text, place text) trong CSDL test, chúng ta tạo chương
trình như sau:
1. Tạo interface DataConnection chứa hàm lấy về một dataSource để cung cấp cho
   JdbcTemplate:

   import javax.sql.DataSource;

   public interface DataConnection {
           public DataSource getDataSource();
   }

2. Tạo cài đặt của interface đó chứa thuộc tính dataSource và các phương thức setter,
   getter:

   import javax.sql.DataSource;

   public class DataConnectionImpl implements DataConnection{
           private DataSource dataSource;

           public DataSource getDataSource() {
                   return dataSource;
           }
           public void setDataSource(DataSource dataSource) {
                   this.dataSource = dataSource;
           }
   }

3. Tạo DataConServlet thực hiện nghiệp vụ là insert dữ liệu.:

   import java.io.IOException;
   import java.io.PrintWriter;
   import javax.servlet.ServletException;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import javax.sql.DataSource;
   import org.springframework.beans.factory.BeanFactory;
   import org.springframework.beans.factory.xml.XmlBeanFactory;
   import org.springframework.core.io.ClassPathResource;
   import org.springframework.jdbc.core.JdbcTemplate;

   public class DataConServlet extends HttpServlet {
           /**
            *
            */
           private static final long serialVersionUID = 1L;

           @Override
           protected void doPost(HttpServletRequest request,
                             HttpServletResponse response) throws ServletException,
      IOException {
                   String name = request.getParameter("name");
                   String place = request.getParameter("place");
                   response.setContentType("text/html");
                   PrintWriter out = response.getWriter();
                   ClassPathResource resource = new
      ClassPathResource("applicationContext.xml");
                   BeanFactory factory = new XmlBeanFactory(resource);
                   DataConnection bean = (DataConnection) factory
                                   .getBean("dataConnection");
                   DataSource ds = bean.getDataSource();
                   try {
                           JdbcTemplate template = new JdbcTemplate(ds);
                           String sql = "insert into user values ('" + name + "','" + place
                                           + "')";
                           template.execute(sql);
                           out.write("A record is added!");
                   } catch (Exception e) {
                           e.printStackTrace();
                   }
             }
      }

   4. Tạo client sử dụng servlet trên:
      <html>
      <body>
      <form method="post"
action="http://localhost:8080/springservlet/data">
             <table>
                   <tr>
                         <th>Name:</th>
                         <td><input type="text" name="name"/></td>
                   </tr>
                   <tr>
                         <th>Place:</th>
                         <td><input type="text" name="place"/></td>
                   </tr>
                   <tr>
                         <td><input type="submit" value="Add"/></td>
                   </tr>
             </table>
      </form>
      </body>
      </html>

  5. Cấu hình bean “dataSource”:

   <?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="hello" class="HelloImpl">
            <property name="greeting">
                  <value>Good Morning!</value>
            </property>
      </bean>
      <bean id="dataSource"
   class="org.springframework.jdbc.datasource.DriverManagerDataSource"
   >
            <property name="driverClassName">
                  <value>com.mysql.jdbc.Driver</value>
            </property>
            <property name="url">
                  <value>jdbc:mysql://localhost:3306/test</value>
            </property>
            <property name="username">
                  <value>root</value>
            </property>
            <property name="password">
                  <value>root</value>
            </property>
      </bean>
      <bean id="dataConnection" class="DataConnectionImpl">
            <property name="dataSource">
                  <ref local="dataSource"/>
            </property>
      </bean>
   </beans>

   6. Cấu hình servlet:

   <?xml version="1.0" encoding="UTF-8"?>
   <web-app id="WebApp_ID" version="2.4"
   xmlns="http://java.sun.com/xml/ns/j2ee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
      <display-name>
      springservlet</display-name>
      <servlet>
            <servlet-name>data</servlet-name>
            <servlet-class>DataConServlet</servlet-class>
      </servlet>
      <servlet-mapping>
            <servlet-name>data</servlet-name>
            <url-pattern>/data</url-pattern>
      </servlet-mapping>
      <welcome-file-list>
            <welcome-file>index.html</welcome-file>
      </welcome-file-list>
   </web-app>

   Để mapping các resource của Hibernate, cần tạo một thể hiện của SessionFactory,
LocalSessionFactoryBean thì được sử dụng cho mục đích này và các thuộc tính:
hibernateProperties, mappingResources và mappingDirectoryLocation phải được thiết lập.
Giống như framework DAO của Spring, chúng ta có HibernateTemplate để tạo đối tượng
SessionFactory. Để truy cập vào dữ liệu với HibernateTemplate, phương thức
execute(HibernateCallback) phải được sử dụng.

   Tương tự như SessionFactory của hibernate, JDO có PersistenceManagerFactory. Nó
được cấu hình bởi LocalPersistenceManagerFactoryBean. JDOTemplate cũng để tạo một đối
tượng của PersistenceManagerFactory. Để truy cập vào dữ liệu với JDOTemplate, phương
thức execute(JDOCallback) phải được sử dụng.

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:13
posted:10/15/2011
language:Vietnamese
pages:15