spring mvc + velocity 搭建实例程序maven版本并且使用的是tomcat容器而不是jetty（step by step）

笔者最近在学习spring mvc 查了很多资料，但用jsp的居多，但项目中需要用velocity，所以说就学习了一下，现将所查资料以及搭建过程陈述如下，供需要的人参考

1.楼主用的是eclipse+maven，如果需要安装请参照其他教程(网上能搜到很多，这里不多赘述)

2.创建maven工程：

file--new--other--maven--maven project

  • Group Id: org.o7planning
  • Artifact Id: SpringMVCVelocity
  • Package: org.o7planning.tutorial.springmvcvelocity

项目创建目录如下:

不用担心现在的错误，错误的原因是没有相应的servlet library.这个错误在后续过程中会自动消除！

Note:
Eclipse 4.4 (Luna) create Maven project structure may be wrong. You need to check.检查文件目录结构，保证在工程下有如下的目录结构：

如果没有就建立相应的source file

3.配置pom.xml文件：

  • pom.xml
<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>org.o7planning</groupId>
    <artifactId>SpringMVCVelocity</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringMVCVelocity Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring framework START -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

        <!-- http://mvnrepository.com/artifact/org.springframework/spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

        <!-- http://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

        <!-- contains: VelocityEngineFactory -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-context-support -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>
        <!-- Spring framework END -->

        <!-- Servlet API -->
        <!-- http://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- http://mvnrepository.com/artifact/org.apache.velocity/velocity -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>1.7</version>
        </dependency>

        <!-- http://mvnrepository.com/artifact/org.apache.velocity/velocity-tools -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-tools</artifactId>
            <version>2.0</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>SpringMVCVelocity</finalName>
        <plugins>

            <!-- Config: Maven Tomcat Plugin -->
            <!-- http://mvnrepository.com/artifact/org.apache.tomcat.maven/tomcat7-maven-plugin -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <!-- Config: contextPath and Port (Default - /SpringMVCVelocity : 8080) -->
                <!--
                <configuration>
                    <path>/</path>
                    <port>8899</port>
                </configuration>
                -->
            </plugin>
        </plugins>
    </build>    

</project>

4.插入xml文件后的目录结构：

  • web.xml
<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>Archetype Created Web Application</display-name>

   <servlet>
      <servlet-name>spring-mvc</servlet-name>
      <servlet-class>
          org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
  </servlet>    

  <servlet-mapping>
      <servlet-name>spring-mvc</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- Other XML Configuration -->
  <!-- Load by Spring ContextLoaderListener -->
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>
       /WEB-INF/root-context.xml,
       /WEB-INF/spring-mvc-servlet.xml
      </param-value>
  </context-param>

   <!-- Spring ContextLoaderListener -->
  <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

</web-app>
  • spring-mvc-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.1.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">

   <!-- Register the annotated components in the container eg : annotated controllers -->
   <context:component-scan base-package="org.o7planning.tutorial.springmvcvelocity.*" />

   <!-- Tell the container that we are going to use annotations -->
   <context:annotation-config />

   <bean id="velocityConfig"
       class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
       <property name="resourceLoaderPath">
           <value>/</value>
       </property>
   </bean>

   <bean id="viewResolver"
       class="org.springframework.web.servlet.view.velocity.VelocityLayoutViewResolver">
       <property name="cache" value="true" />
       <property name="prefix" value="/WEB-INF/views/" />
       <property name="layoutUrl" value="/WEB-INF/layouts/layout.vm" />
       <property name="suffix" value=".vm" />
   </bean>

</beans>
  • root-context.xml
<?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.xsd">

   <!-- Empty -->

</beans>

5.需要的velocity文件（.vm文件）文件结构：

  • /WEB-INF/fragments/_header.vm
<div style="background: #E0E0E0; height: 80px; padding: 5px;">
   <div style="float: left">
       <h1>My Site</h1>
   </div>
   <div style="float: right; padding: 10px;">
       Search <input name="search">
   </div>
</div>
  • /WEB-INF/fragments/_footer.vm
<div
    style="background: #E0E0E0; text-align: center; padding: 5px; margin-top: 10px;">
    @Copyright mysite.com
</div>
  • /WEB-INF/layouts/layout.vm
<html>
<head>
  <title>Spring & Velocity</title>
</head>
<body>
   <div>
       #parse("/WEB-INF/fragments/_header.vm")
   </div>

   <div>

     <!-- View abc.vm is inserted here -->
     <!-- Noi dung View abc.vm se duoc tren tai day -->
     $screen_content

   </div>

   <div>
       #parse("/WEB-INF/fragments/_footer.vm")
   </div>
</body>
</html>

The $screen_content variable is used by the VelocityLayoutViewResolver to include the result of an other VM in the layout

  • /WEB-INF/views/index.vm
<h1>Index</h1>

<h2>Department list</h2>
<table border="1">
<tr>
  <th>Dept No</th>
  <th>Dept Name</th>
</tr>
#foreach($dept in $departments)
   <tr>
    <td>$dept.deptNo</td>
    <td>$dept.deptName</td>
   </tr>
#end
</table>

6.项目的mvc模式java文件结构视图：

  • Department.java
package org.o7planning.tutorial.springmvcvelocity.model;

public class Department {

   private Integer deptId;
   private String deptNo;
   private String deptName;
   private String location;

   public Department() {
   }

   public Department(Integer deptId, String deptName, String location) {
       this.deptId = deptId;
       this.deptNo = "D" + deptId;
       this.deptName = deptName;
       this.location = location;
   }

   public Integer getDeptId() {
       return deptId;
   }

   public void setDeptId(Integer deptId) {
       this.deptId = deptId;
   }

   public String getDeptNo() {
       return deptNo;
   }

   public void setDeptNo(String deptNo) {
       this.deptNo = deptNo;
   }

   public String getDeptName() {
       return deptName;
   }

   public void setDeptName(String deptName) {
       this.deptName = deptName;
   }

   public String getLocation() {
       return location;
   }

   public void setLocation(String location) {
       this.location = location;
   }
}
  • DepartmentService.java
package org.o7planning.tutorial.springmvcvelocity.model;

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Service;

@Service
public class DepartmentService {

    public List<Department> listDepartment() {
        List<Department> list = new ArrayList<Department>();

        list.add(new Department(1, "Operations", "Chicago"));
        list.add(new Department(2, "HR", "Hanoi"));
        return list;
    }
}

The classes annotated by @Controller or @Service be regarded as the Bean, and Spring will automatically inject dependencies in the Field annotated by @Autowired annotation.

  • MainController.java
package org.o7planning.tutorial.springmvcvelocity.controller;

import java.util.List;

import org.o7planning.tutorial.springmvcvelocity.model.Department;
import org.o7planning.tutorial.springmvcvelocity.model.DepartmentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class MainController {

    @Autowired
    private DepartmentService deptService;

    @RequestMapping(value = { "/", "/welcome" }, method = RequestMethod.GET)
    public String welcomePage(Model model) {
        List<Department> list = deptService.listDepartment();
        model.addAttribute("departments", list);
        return "index";
    }
}

7.maven运行步骤，使用的是tomcat容器，而不是jetty

In the first, before running the application you need to build the entire project.

Right-click the project and select:

运行配置参数:

Enter:

  • Name: Run SpringMVCVelocity
  • Base directory: ${workspace_loc:/SpringMVCVelocity}  //其中SpringMVCVelocity指的是项目的名字，这行的意思就是找到硬盘中的项目位置，点击下面的 Browse Workspace进行选择
  • Goals: tomcat7:run

Click Run:

端口号的设置在pom.xml中

执行后的效果图如下：

时间： 2024-10-17 22:39:30

spring mvc + velocity 搭建实例程序maven版本并且使用的是tomcat容器而不是jetty（step by step）的相关文章

Spring MVC 环境搭建（maven+SpringMVC+mybatis+Freemarker） ----DawnHeaven

Spring MVC 环境搭建(maven+SpringMVC+mybatis+Freemarker)       ------DawnHeaven 一.准备工作 1.Eclipse Java EE IDE(4.4.1) 2.JDK 3.Tomcat 4.Maven  maven安装指南 二.构建工程 1.file->new->Project 2.next 3. next 4.next 5.finish 工程目录如下 三.完善项目 首先,完善目录,增加重要的source Folder,这个不是

[读后感]spring Mvc 教程框架实例以及系统演示下载

太阳火神的美丽人生 (http://blog.csdn.net/opengl_es) 本文遵循"署名-非商业用途-保持一致"创作公用协议 转载请保留此句:太阳火神的美丽人生 -  本博客专注于 敏捷开发及移动和物联设备研究:iOS.Android.Html5.Arduino.pcDuino,否则,出自本博客的文章拒绝转载或再转载,谢谢合作. 不要好意思,昨晚写的,睡着忘发了,后附是篇好文,赶紧w分享一下. 感脚着,俺好像做了件聪明事儿,却不知会不会遭到不理解. 转载的好文,是不会推荐到

spring mvc构建WEB应用程序入门例子

在使用spring mvc 构建web应用程序之前,需要了解spring mvc 的请求过程是怎样的,然后记录下如何搭建一个超简单的spring mvc例子. 1) spring mvc的请求经历 请求由DispatcherServlet分配给控制器(根据处理器映射),在控制器完成处理后,请求会被发送到一个视图(根据viewController解析逻辑视图) 来呈现输出结果. 整理成下图所示: 2)搭建一个简单的spring mvc例子 ①创建一个maven工程,其中pom中要有spring相关

Spring MVC 框架搭建及具体解释

如今主流的Web MVC框架除了Struts这个主力 外.其次就是Spring MVC了,因此这也是作为一名程序猿需要掌握的主流框架.框架选择多了.应对多变的需求和业务时,可实行的方案自然就多了. 只是要想灵活运用Spring MVC来应对大多数的Web开发,就必需要掌握它的配置及原理. 一.Spring MVC环境搭建:(Spring 2.5.6 + Hibernate 3.2.0) 1. jar包引入 Spring 2.5.6:spring.jar.spring-webmvc.jar.com

Spring MVC 环境搭建（一）

一.建立 JavaWeb 项目 1.建立一个 Java 项目. 2.在项目下新建一个文件夹 webapp (命名可自取,这个目录即是网站根目录),再在该文件夹下新建一个 WEB-INF 文件夹(命名固定),WEB-INF 作为 Tomcat 启动后的安全文件夹,浏览器不能访问到该目录下的资源.tomcat 启动会默认会在此目录下读取相应配置文件. 3.在 WEB-INF 下建立 web.xml 文件(命名固定),从 tomcat 安装路径 /conf/web.xml 中拷贝基本的文档结构,修改相

Spring MVC 框架搭建及详解

一.Spring MVC环境搭建:(Spring 2.5.6 + Hibernate 3.2.0) 1. jar包引入 Spring 2.5.6:spring.jar.spring-webmvc.jar.commons-logging.jar.cglib-nodep-2.1_3.jar Hibernate 3.6.8:hibernate3.jar.hibernate-jpa-2.0-api-1.0.1.Final.jar.antlr-2.7.6.jar.commons-collections-3

Spring MVC 环境搭建

作为java领域不可或缺的一员猛将,今天我开始正式接触它.与所有框架一样,我们第一步要做的就是搭建环境. 首先我们需要准备的材料: Eclipse tomcat(我用的是7.0) spring mvc jar包(我用的是3.2的) 有了这些工具,下面我们开始吧! 1.新建一个项目 Eclipse新建 Dynamic Web project 选择相应的服务器容器(我用的是Tomcat7.0),一路下一步到完成. 2.引入jar包 SpringMVC使用的jar包基本和Spring是相同的,我们可以

spring mvc开发入门实例demo源代码下载，很适合新手入门学习用。

原文:spring mvc开发入门实例demo源代码下载,很适合新手入门学习用. 源代码下载:http://www.zuidaima.com/share/1550463469046784.htm Eclipse + Maven + Spring MVC - Simple Example 源代码框架截图:

Java Spring MVC项目搭建（一）——Spring MVC框架集成

1.Java JDK及Tomcat安装 我这里安装的是JDK 1.8 及 Tomcat 8,安装步骤详见:http://www.cnblogs.com/eczhou/p/6285248.html 2.下载Eclipse并安装 我这里安装的是Java EE neon 64位版本. 3.建立Spring MVC项目 3.1.打开安装好的eclipse ,选择File->new->other.在弹出的框内选择Web->Dynamic Web Project , 选择Next. 3.2.给项目起