Loading...
Hello World Spring MVC - Lập Trình Web Spring MVC

Hello World Spring MVC - Lập Trình Web Spring MVC

1:05 PM
Trong bài viết này, mình sẽ giới thiệu các bạn một framework phổ biến nhất của nền tảng Java trong xây dựng ứng dụng Web, đặc biệt là các ứng dụng doanh nghiệp lớn - Enterprise application.


Spring framework là Java framework được dùng nhiều nhất hiện nay, các công ty làm về Java hầu như đều yêu cầu kiến thức về Spring khi tuyển dụng. Hãy học Spring nếu bạn muốn bước vào thế giới Java và phát triển sự nghiệp lập trình với Java.
Bài này mình sẽ bắt đầu với một ví dụ kinh điển "Hello world" sử dụng Spring MVC 4.
Cần phải nói thêm Spring là một hệ sinh thái rất lớn hiện nay. Nó cung cấp rất nhiều framework bên trong với nhiều mục đích sử dụng và yêu cầu lập trình khác nhau. Spring MVC chỉ là một framework trong "thế giới Spring".
Tốt nhất các bạn nên tìm hiểu về Spring core để có cái nhìn tổng thể về các quy tắc thiết kế và xây dựng trong Spring. Bạn có thể tìm hiểu trên mạng nha, hoặc tương lai mình sẽ có loạt bài khác về nó.

Bắt đầu với Spring MVC thôi!

Technologies sẽ dùng trong bài này gồm:

  • Spring 4.1.6.RELEASE
  • Maven 3
  • JDK 1.8
  • IDE: Eclipse for Java EE (chơi bản mới nhất ấy, cho nó máu :))
  • Server Tomcat 8


1. Tạo một project maven với Eclipse

Mở Eclipse của bạn lên nào.
Chọn File -> New -> Maven Project




Chọn Next nhé


Chọn maven web app archetype rồi nhấn Next

 Nhập các thông tin cần thiết cho một project mới, rồi chọn Finish.


2. Thêm Spring dependencies vào Maven pom.xml

Bạn thêm depedencies cho project bằng cách mở file pom.xml và thêm vào như sau:

 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.nmt.springmvc</groupId>
 <artifactId>HelloWorld</artifactId>
 <packaging>war</packaging>
 <version>0.0.1-SNAPSHOT</version>
 <name>HelloWorld Maven Webapp</name>
 <url>http://maven.apache.org</url>
 <properties>
  <springframework.version>4.1.6.RELEASE</springframework.version>
 </properties>

 <dependencies>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>${springframework.version}</version>
  </dependency>
  <dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>3.1.0</version>
  </dependency>
  <dependency>
   <groupId>javax.servlet.jsp</groupId>
   <artifactId>javax.servlet.jsp-api</artifactId>
   <version>2.3.1</version>
  </dependency>
  <dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>jstl</artifactId>
   <version>1.2</version>
  </dependency>
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>3.8.1</version>
   <scope>test</scope>
  </dependency>
 </dependencies>
 <build>
  <finalName>HelloWorld</finalName>
 </build>
</project>


3. Tạo Controller class

Thêm một package vào src/main/java


Tạo một class mới trong package vừa tạo với nội dung:

package com.nmt.springmvc.controler;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/")
public class HelloWorldController {
 
    @RequestMapping(method = RequestMethod.GET)
    public String sayHello(ModelMap model) {
        model.addAttribute("nameUser", "nmtien");
        return "welcome";
    }
 
    @RequestMapping(value="/helloagain", method = RequestMethod.GET)
    public String sayHelloAgain(ModelMap model) {
        model.addAttribute("nameUser", "nmtien");
        return "welcome";
    }
}

Giải thích một chút nào:

  • @Controller: đánh dấu class này là một spring bean và đóng vai trò là một controller tiếp nhận các HTTP request tới. Ví dụ ở đây, tất cả các request vào đường dẫn root '/' sẽ được xữ lý bởi controller này. Bạn có thể thay đổi theo ý muồn bằng cách đổi giá trị của @RequestMapping.
  • @RequestMapping: dùng định nghĩa những request đến sẽ được xữ lý bởi class hay method nào. Bạn có thể thấy, nó có thể dùng cho class level và cả method level, tùy vào độ phức tạp của URL do bạn định nghĩa. Ở ví dụ trên, ta dùng nó ở cả 2 level. @RequestMapping có vài thuộc tích như value(chì định path url), method (chỉ định loại http request là GET/POST/PUT...), params
  • Nếu bạn không cung cấp value cho @RequestMapping annotation thì value ở class level sẽ được dùng (trường hợp method sayHello)
  • Trong trường hợp bạn không cung cấp giá trị cho thuộc tính method của @RequestMapping thì nó sẽ chấp nhật tất cả các loại http request.
  • ModelMap: bản chất nó là một implementation của cấu trúc dữ liệu Map. Nó cho phép bạn lưu giữ dữ liệu của một request. Ví dụ, ở đây bạn thêm một attibute tên nameUser, attribute này sẽ được truy xuất từ view jsp.
  • Cuối cùng là lệnh return: nó trả về "welcome". Đây sẽ là tên của view mà ta sẽ tạo sau. Ở đây ta sẽ dùng JSP như view  để hiển thị dữ liệu và thông tin ra cho người dùng. Chúng ta sẽ cấu hình nó ở phần tiếp theo.

4. Tạo JSP view

Tạo mới một folder views bên trong thư mục WEB-INF.  Tạo mới một jsp file tên welcome như đã định nghĩa ở phần trước: WEB-INF/views/welcome.jsp




<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@ page isELIgnored ="false" %> 

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Hello World - Spring MVC</title>
</head>
<body>
 Hello ${nameUser}
</body>
</html>

Bạn có thể thấy, trong jsp file ta có thể truy xuất giá trị của nameUser thông qua cú pháp ${}

5. Cấu hình Spring MVC

Spring cho phép bạn cấu hình bằng xml truyền thống hoặc dùng cấu hình java annotation. Tùy bạn thôi. Bài này mình sẽ dùng xml để cấu hình cho ví dụ này.

Trong WEB-INF folder, tao một xml file spring-servlet.xml như sau (tên gì cũng được nhưng nhớ để định nghĩa trong web.xml sau này)



<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    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-4.0.xsd
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
 
    <context:component-scan base-package="com.nmt.springmvc" />
 
    <mvc:annotation-driven />
     
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix">
            <value>/WEB-INF/views/</value>
        </property>
        <property name="suffix">
            <value>.jsp</value>
        </property>
    </bean>
 
</beans>

Giải thích một chút nào:
  • mvc:annotation-driven: nói rằng ta có thể định nghĩa beans mà không nhất thiết phải khai báo chúng ở xml file hay phải implement một interface,... Ví dụ, ta chỉ cần dùng annotation @Controller như phần trước để chỉ định một class là bean mà không cần khai báo trong xml file. Cái này thuần về spring core, bạn tốt nhất tìm hiểu thêm để hiểu rõ. Nói cho dể hiểu là trong Spring có khái niệm bean, nó là cốt lỗi của Spring, và cần được định nghĩa hay khai báo trước để framework nó biết trước khi khởi chạy ứng dụng. Khi dùng @Controller, hay sau này có thêm @Component, @Service,... thì bạn không cần khai báo bean cho các class đã được đánh dấu với các annotaion này. Spring sẽ tự tìm và đang ký với bean factory với điều kiện phải cấu hình mvc:annotation-driven cho nó.
  • context:component-scan: cái này liên quan đến cái trên, bạn phải chỉ định cho spring nơi nào (classpath) để nó scan và tìm bean được cấu hình với các annotation @Controller, @Service... Dùng base-package để chỉ định package cần thiết nhé. Ở đây tôi chỉ định là "com.nmt.springmvc" vì nó sẽ cover được package controller của tui hoặc sau này tui thêm package khác như service thì cấu hình này vẫn chạy tốt.
  • Bên cạnh đó, ta cũng định nghĩa view resolver để spring biết được nơi mà đi tìm jsp file. Với cấu hình prefix và suffix như trên, tất cả view của project ta phải đặt trong thư mục /WEB-INF/views/ và phải là jsp file.
Tiếp theo, ta cần cấu hình web.xml như sau:


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
 <display-name>Archetype Created Web Application</display-name>

 <servlet>
  <servlet-name>dispatcher</servlet-name>
  <servlet-class>
   org.springframework.web.servlet.DispatcherServlet
  </servlet-class>
  <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/spring-servlet.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
  <servlet-name>dispatcher</servlet-name>
  <url-pattern>/</url-pattern>
 </servlet-mapping>
</web-app>

Giải thích tiếp nào:


  • DispatcherServlet: đây là một servlet quan trọng nhất trong mô hình MVC của Spring MVC. Nó có nhiệm vụ nhận các request đến và điều hướng, ủy thác cho một controller tương ứng để xử lý. Sau đó, nó chuyển response từ controller sang view tương ứng. Nó là Front Controller trong mô hình trên.
  • Chú ý contextConfigLocation: nó cho phép bạn khai báo file config. Do đó, bên không nhất thiết đặt tên spring-servlet.xml hay đặt nó trong WEB-INF. Chỉ cần khai báo đúng nơi, đúng chổ là được.
That's all! Sau tất cả ta có project structure như sau:

6. Chạy ứng dụng, xem thành quả

Bạn cần một server tomcat để chạy ứng dụng.
Add server tomcat như sau:



Sau khi server started, truy cập vào http://localhost:8080/helloworld/ để xem kết quả:


Truy cập http://localhost:8080/helloworld/helloagain


Như vậy, ta đã hoàn thành ví dụ Hello world dùng Spring MVC 4 với cấu hình dùng XML.
Hẹn gặp lại ở các bài tiếp theo về Spring MVC.

Download source code tại đây.

Tác giả: Nguyễn Minh Tiến - nmT

Next
« Prev Post
Previous
Next Post »
Subscribe to: Post Comments (Atom)
Loading...