Web应用技术（第十五周/END）

春风LiuK

已于 2023-06-08 10:48:16 修改

阅读量703

点赞数 2

分类专栏： Web应用技术学习文章标签： java 开发语言 spring mvc maven

于 2023-05-30 20:52:13 首次发布

本文链接：https://blog.csdn.net/liukuande/article/details/130956796

版权

Web应用技术学习专栏收录该内容

33 篇文章 0 订阅

订阅专栏

本次练习基于how2j和课本，进行SSM的初步整合，理解SSM整合的原理、好处。

Alt

1.简单的实例项目：

how2j

2.原理分析：

具体见流程图：
![在这里插入图片描述](https://img-blog.csdnimg.cn/aa82a211313148fd990e4e1636ad26c2.jpeg

简要的说明：
将我们（用户）作为整个流程的起点：当我们像浏览器发送访问请求时，我们首先出发的是整个web项目的核心配置文件web.xml，它将所有的请求都交给控制器处理，同时调用视图解析器，为我们（用户）呈现一个视图，当然，此时的视图是没有数据的。
控制器实例化CategoryService对象（具体包括：通过Mybatis在数据库中请求数据，接着通过Spring的反转控制和依赖注入Category，实例化对象"CategoryMapper"，然后通过CategoryServiceImpl的list方法，获取CategoryMapper中的数据，最后通过上转型方式，真正实现实例化CategoryService），该对象的list方法，其实也就是CategoryServiceImpl的list方法，会获取到多个Category对象，通过mav的addObject方法，成为可以被jsp页面调用的数据。至此，用户视图就有了数据。

3.浅谈使用SSM框架化：

当阳光更炽烈，黑暗也更加阴冷。我们在使用SSM来开发项目时，可以利用spring框架下很多已经写好的东西，比如说spring中依赖注入和反转控制，我们就不必自己new了，再比如说mybatis中的sql语句配置文件化，提高通用性和可重用性，又比如说springmvc的视图解析器，我们就不需要自己去实现http接口去重定向了。这很大程度上提高了我们的开发效率，但是当我们过度框架化时，我们就会被局限在框架之中，比如说spring的声明式事务管理，我们只能用spring为我们准备好的那一套事务处理的方式，而不能在ssm框架下实现对特殊业务场景的满足。
显然，我们开发新技术，使用新框架不是为了走极端，而是在寻求“中庸之道”，或许ssm是这个中庸之道的“立足点”。

4.SSM框架下的注解辨析:

1.Spring的注解：

常见的Spring注解：

注解名	作用
@Autowired	自动装配依赖对象，即自动将需要的对象注入到类中
@Resource	JavaEE的注解，不是Spring的注解，但是Spring也支持@Resource注解。它的作用和@Autowired类似，也是用来注入依赖对象的
@Component	将类标记为Spring组件，告诉Spring框架将这个类纳入到Spring容器中管理
@Aspect	定义切面，即声明一组横切关注点和它们的逻辑关系，用来描述在什么时候、在哪里应用哪些通知（Advice）
@Around	定义环绕通知，即在方法执行前后都执行一些逻辑
@Before	定义前置通知，即在方法执行前执行一些逻辑
@After	定义后置通知，即在方法执行后执行一些逻辑
@ContextConfiguration	指定Spring应用程序的配置文件或Java配置类，用来配置Spring容器
@Service	将类标记为Spring服务类
@Repository	将类标记为Spring数据访问对象
@Scope	控制Spring容器如何管理Bean的实例化、销毁和缓存
@Value	注入属性值，即将配置文件中的值注入到Bean的属性中

2.SpringMVC的注解：

SpringMVC常见的注解有两个：@Controller和@RequestMapping，下面举一个简单的例子对两者进行解释和示范：
@Controller注解用于标识一个类是SpringMVC的控制器，处理客户端请求并返回响应结果。通常，控制器类中的方法使用@RequestMapping注解来指定处理的请求URL和请求方法类型。

例如，下面的代码片段展示了一个使用@Controller注解的示例：

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public ModelAndView getUserById(@PathVariable("id") Long id) {
        User user = userService.getUserById(id);
        ModelAndView modelAndView = new ModelAndView("user");
        modelAndView.addObject("user", user);
        return modelAndView;
    }

    // other methods...
}

在上面的示例中，UserController类使用@Controller注解标识为SpringMVC的控制器，并使用@RequestMapping注解指定了处理的请求URL为"/user/{id}"，请求方法类型为GET。getUserById方法用于处理该请求，并返回一个包含用户信息的ModelAndView对象。

3.Mybatis的注解：

Mybatis的注解方式是一种使用注解来替代Mapper
XML文件的方式，通过在Java代码中添加注解来定义SQL语句和Java对象之间的映射关系。
Mybatis的一般方式则是通过Mapper
XML文件来定义SQL语句和Java对象之间的映射关系。

下面分别对这两种方式进行详细解释，并且举例说明：

Mybatis的注解方式

使用注解方式，需要在Mapper接口的方法上添加对应的注解（使用注解方式则不用为Mapper接口写一个xml兄弟文件来定义SQL语句了），如@Select、@Insert、@Update、@Delete等，同时在注解中定义SQL语句和Java对象之间的映射关系。下面是一个使用注解方式的示例：

public interface UserMapper {
    @Select("SELECT id, name, age FROM user WHERE id = #{id}")
    User getUserById(int id);
}

通过以上代码，我们可以定义一个getUserById方法，使用@Select注解来定义查询语句，并且将查询结果映射成User对象。在使用时，可以直接调用该方法来执行查询操作，如下所示：

// 获取Mapper对象
UserMapper mapper = session.getMapper(UserMapper.class);

// 执行查询操作
User user = mapper.getUserById(1);

// 输出查询结果
System.out.println(user.getId() + ", " + user.getName() + ", " + user.getAge());

Mybatis的一般方式

使用一般方式，需要在Mapper XML文件中定义SQL语句和Java对象之间的映射关系，然后在Java代码中通过SqlSession对象来执行SQL语句。下面是一个使用一般方式的示例：

UserMapper.xml文件：

<!-- 定义查询语句 -->
<select id="getUserById" resultType="com.example.User">
    SELECT id, name, age FROM user WHERE id = #{id}
</select>

UserMapper接口：

public interface UserMapper {
    User getUserById(int id);
}

在使用时，需要先加载UserMapper.xml文件，并且获取Mapper对象，然后通过该对象来执行查询操作，如下所示：

// 加载UserMapper.xml文件
InputStream inputStream = Resources.getResourceAsStream("UserMapper.xml");
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

// 创建SqlSession对象
SqlSession session = sessionFactory.openSession();

// 获取Mapper对象
UserMapper mapper = session.getMapper(UserMapper.class);

// 执行查询操作
User user = mapper.getUserById(1);

// 输出查询结果
System.out.println(user.getId() + ", " + user.getName() + ", " + user.getAge());

// 关闭SqlSession对象
session.close();

下面是Mybatis注解方式和一般方式的优劣对比：

开发效率

优劣：注解方式相对于一般方式来说，开发效率更高，因为注解方式不需要编写Mapper XML文件，可以直接在Java代码中使用注解来定义SQL语句和Java对象之间的映射关系，从而减少了编写和维护Mapper XML文件的工作量。

可读性和可维护性

优劣：一般方式相对于注解方式来说，可读性和可维护性更高，因为Mapper XML文件可以更加清晰地定义SQL语句和Java对象之间的映射关系，方便开发人员进行阅读和修改。而注解方式将SQL语句和Java对象之间的映射关系直接写在Java代码中，可能会导致代码比较冗长，可读性和可维护性较差。

SQL语句的复杂度

优劣：一般方式相对于注解方式来说，更适合处理复杂的SQL语句，因为Mapper XML文件可以更加灵活地定义SQL语句和Java对象之间的映射关系，支持动态SQL、多表联查等复杂操作。而注解方式则相对简单，不太适合处理复杂的SQL语句。

性能

优劣：注解方式相对于一般方式来说，性能更高，因为注解方式不需要解析Mapper XML文件，可以直接在Java代码中执行SQL语句，从而提高了执行效率。而一般方式需要解析Mapper XML文件，并且使用XML解析器来解析SQL语句，可能会导致性能略微降低。

综上所述，Mybatis注解方式和一般方式各有优劣，需要根据具体的情况来选择合适的方式。如果需要提高开发效率和简化代码结构，可以选择注解方式；如果需要提高可读性和可维护性，以及处理复杂的SQL语句，可以选择一般方式。
值得一提的是：如果Spring框架的设计目标之一是实现松耦合的组件之间的依赖关系，那么我们在SSM框架中通常更多使用的是一般方式。

5.分页的流程及原理（手工分页/CRUD之R）：

_{本次练习基于已经成功整合SSM。}

（1）前置准备：

清空数据库中的数据表category_：
在这里插入图片描述

重新编写Mybatis.java，插入整齐有序的数据便于观察，代码如下：

package com.how2java.test;

import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.how2java.mapper.CategoryMapper;
import com.how2java.pojo.Category;
import com.how2java.util.Page;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class MybatisTest {

	@Autowired
	private CategoryMapper categoryMapper;

	// 测试添加分类
	@Test
	public void testAdd() {
		for (int i = 0; i < 100; i++) {
			Category category = new Category();
			category.setId(i);
			category.setName(" Category"+i);
			categoryMapper.add(category);
		}

	}

	

}

同理，修改`Category.xml`的代码，如下：

 <insert id="add" parameterType="Category" >
	        insert into category_ (id, name ) values (#{id},#{name})    
	    </insert>

在程序编写框的空白处Run as——>JUnit Test

在这里插入图片描述
刷新数据表，如图所示：

在这里插入图片描述

修改那两份代码是为了使我们在表中添加的数据的id的标号是升序的。

（2）原理分析：

我们的分页是通过超链接(更具体来说，是参数传递)和sql语句的limit关键字来实现的。实现分页，我们必须关心两件事：
①我们的分页的一个页面，即当前页面，是从那一条数据开始的。
②我们当前页需要展示几条数据。
着两个数据恰好就是limit的两个参数，第一个参数由每一次进行上一页、下一页等换页操作实时传递，第二个参数由我们在分页的实体类中规定。
以下一页为例进行流程分析：

我们点击下一页，像浏览器请求"listCategory?start=5"
请求被web.xml的前端拦截器捕获，交由springMVC.xml控制，进而调用控制器"CategoryController.java"，控制器通过Spring和上转型注入CategoryService
控制器调用其被标记为listCategory的方法，并向其传递一个对象型参数Page，Page的属性start被参数传递的start覆盖，值为’5’
调用CategorySerVice对象带参数的方法list(page)，这个方法会在其函数体的内部调用categoryMapper的list（page）方法，此后会执行id为list的sql语句：

 <!-- 定义分页查询操作，返回结果类型为Category -->
	    <select id="list" resultType="Category">
	        select * from   category_      
	        <!-- 判断是否有分页参数 -->
	        <if test="start!=null and count!=null">
                    limit #{start},#{count}
            </if>
	    </select>

limit关键字有两个参数，第一个参数定位了查询的起点，第二参数限定了查询几个，在这里我们查询的起点是5，向后查询5个（不包括起点），返回category结果，在CategoryMapper的对象中形成一个Category对象列表，作为函数返回值return给CategoryService
CategoryService的list方法继续return，最后列表赋值给cs对象
通过addObeject（）方法添加到视图中，至此，我们就得到了在新的视图中呈现6、7、8、9、10即id依次为94、93、92、91、90的这五条数据了。

6.SSM框架下的简单CRUD:

（1）实现思路：

我们的crud本质上，也是一种向用户提供的服务，或者说用户的需求。因此为了实现CRUD：

我们需要修改视图，增加相关按钮，以供用户点击
我们需要修改定义服务的接口，以实现接口最终实现功能
我们需要修改DAO(CategoryMapper)，以实现与数据库的交互。
我们需要修改控制器，处理用户不同的/更多的请求

（2）具体实现：

添加按钮：

在jsp界面增加超链接，以向浏览器发送请求U和D的请求，相关代码片段如下：

		<td><a href="editCategory?id=${c.id}">编辑</a></td>
	    <td><a href="myDeleteTest?id=${c.id}">删除</a></td>

	<div style="text-align:center;margin-top:40px">
		
		<form method="post" action="addCategory">
		分类id:<input name="id" value="" type="text"> <br><br>
			分类名称： <input name="name" value="" type="text"> <br>
			<input type="submit" value="增加分类">
		</form>

	</div>

完整的listCategory代码如下：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" import="java.util.*"%>
 
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 
<!-- 显示分类列表 -->
<div style="width:500px;margin:0px auto;text-align:center">
	<table align='center' border='1' cellspacing='0'>
	    <tr>
	        <td>id</td>
	        <td>name</td>
	        	        <td>编辑</td>
	            <td>删除</td>
	    </tr>
	    <!-- 遍历分类列表 -->
	    <c:forEach items="${cs}" var="c" varStatus="st">
	        <tr>
	            <td>${c.id}</td>
	            <td>${c.name}</td>
	            <td><a href="editCategory?id=${c.id}">编辑</a></td>
	            <td><a href="myDeleteTest?id=${c.id}">删除</a></td>

	        </tr>
	    </c:forEach>
	</table>
	<!-- 分页导航 -->
	<div style="text-align:center">
		<a href="?start=0">首  页</a>
		<a href="?start=${page.start-page.count}">上一页</a>
		<a href="?start=${page.start+page.count}">下一页</a>
		<a href="?start=${page.last}">末  页</a>
	</div>
	
	<div style="text-align:center;margin-top:40px">
		
		<form method="post" action="addCategory">
		分类id:<input name="id" value="" type="text"> <br><br>
			分类名称： <input name="name" value="" type="text"> <br>
			<input type="submit" value="增加分类">
		</form>

	</div>	
 </div>

添加接口：

在CategoryService.java中，增加如下代码片段：

	void add(Category c);
	void update(Category c);
	void delete(Category c);

完整的代码如下：

package com.how2java.service;

import java.util.List;

import com.how2java.pojo.Category;
import com.how2java.util.Page;

public interface CategoryService {

	List<Category> list();
	int total();
	List<Category> list(Page page);
	void add(Category c);
	void update(Category c);
	void delete(Category c);
	Category get(int id);

}

在CategoryServiceImpl.java中，增加如下代码片段：

	@Override
	public void add(Category c) {
		categoryMapper.add(c);
		
	}


	@Override
	public void update(Category c) {
		categoryMapper.update(c);
	}


	@Override
	public void delete(Category c) {
		categoryMapper.delete(c.getId());
	}

完整代码如下：

package com.how2java.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.how2java.mapper.CategoryMapper;
import com.how2java.pojo.Category;
import com.how2java.service.CategoryService;
import com.how2java.util.Page;

@Service
public class CategoryServiceImpl  implements CategoryService{
	@Autowired
	CategoryMapper categoryMapper;
	
	
	public List<Category> list(){
		return categoryMapper.list();
	}


	@Override
	public List<Category> list(Page page) {
		// TODO Auto-generated method stub
		return categoryMapper.list(page);
	}


	@Override
	public int total() {
		return categoryMapper.total();
	}


	@Override
	public void add(Category c) {
		categoryMapper.add(c);
		
	}


	@Override
	public void update(Category c) {
		categoryMapper.update(c);
	}


	@Override
	public void delete(Category c) {
		categoryMapper.delete(c.getId());
	}


	@Override
	public Category get(int id) {
		// TODO Auto-generated method stub
		return categoryMapper.get(id);
	};

}

完善Dao：

在CategoryMapper.java中添加add、delete、update方法用于支持CUD，原有的list方法支持分页（即为R，分页只是改变了数据的呈现形式）

完整代码如下：

package com.how2java.mapper;
 
import java.util.List;

import com.how2java.pojo.Category;
import com.how2java.util.Page;
 
public interface CategoryMapper {
 
    // 添加分类
    public int add(Category category);  
       
    // 删除分类
    public void delete(int id);  
       
    // 根据id获取分类
    public Category get(int id);  
     
    // 更新分类
    public int update(Category category);   
       
    // 获取所有分类列表
    public List<Category> list();
    
    // 分页获取分类列表
    public List<Category> list(Page page);
    
    // 获取分类总数
    public int total();  
    
}

category.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
	PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
	"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- 定义命名空间，用于与接口进行映射 -->
	<mapper namespace="com.how2java.mapper.CategoryMapper">
	    
	    <!-- 定义插入操作，参数类型为Category -->
	    <insert id="add" parameterType="Category" >
	        insert into category_ (id, name ) values (#{id},#{name})    
	    </insert>
	    
	    <!-- 定义删除操作，参数类型为Category -->
	    <delete id="delete" parameterType="Category" >
	        delete from category_ where id= #{id}   
	    </delete>
	    
	    <!-- 定义查询操作，参数类型为int，返回结果类型为Category -->
	    <select id="get" parameterType="_int" resultType="Category">
	        select * from   category_  where id= #{id}    
	    </select>

	    <!-- 定义更新操作，参数类型为Category -->
	    <update id="update" parameterType="Category" >
	        update category_ set name=#{name} where id=#{id}    
	    </update>
	    
	    <!-- 定义查询所有操作，返回结果类型为Category -->
	    <select id="list" resultType="Category">
	        select * from   category_      
	        <!-- 判断是否有分页参数 -->
	        <if test="start!=null and count!=null">
                    limit #{start},#{count}
            </if>
	    </select>
	    
	    <!-- 定义查询总数操作，返回结果类型为int -->
	    <select id="total" resultType="int">
	        select count(*) from   category_      
	    </select>	    	    
	</mapper>

完善控制器：

在CategoryController.java中增加如下代码：

// 处理添加分类的请求
	@RequestMapping("addCategory")
	public ModelAndView addCategory(Category category){
		categoryService.add(category);
		ModelAndView mav = new ModelAndView("redirect:/listCategory");
	    return mav;
	}	
	
	// 处理删除分类的请求
	@RequestMapping("myDeleteTest")
	public ModelAndView deleteCategory(Category category){
		categoryService.delete(category);
		ModelAndView mav = new ModelAndView("redirect:/listCategory");
		return mav;
	}	
	
	// 处理编辑分类的请求
	@RequestMapping("editCategory")
	public ModelAndView editCategory(Category category){
		Category c= categoryService.get(category.getId());
		ModelAndView mav = new ModelAndView("editCategory");
		mav.addObject("c", c);
		return mav;
	}	
	
	// 处理更新分类的请求
	@RequestMapping("updateCategory")
	public ModelAndView updateCategory(Category category){
		categoryService.update(category);
		ModelAndView mav = new ModelAndView("redirect:/listCategory");
		return mav;
	}

完整代码如下：

// 引入需要的类
package com.how2java.controller;

import java.util.Collections;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.how2java.pojo.Category;
import com.how2java.service.CategoryService;
import com.how2java.util.Page;

// 定义一个Spring MVC控制器类
@Controller
@RequestMapping("")
public class CategoryController {
	@Autowired
	CategoryService categoryService;

	// 处理请求，返回模型和视图对象
	@RequestMapping("listCategory")
	public ModelAndView listCategory(Page page){
	
		ModelAndView mav = new ModelAndView();
		List<Category> cs= categoryService.list(page);
		
		int total = categoryService.total();
		
		page.caculateLast(total);
		
		// 添加参数
		mav.addObject("cs", cs);
		// 设置视图名称
		mav.setViewName("listCategory");
		return mav;
	}
	
	// 处理添加分类的请求
	@RequestMapping("addCategory")
	public ModelAndView addCategory(Category category){
		categoryService.add(category);
		ModelAndView mav = new ModelAndView("redirect:/listCategory");
	    return mav;
	}	
	
	// 处理删除分类的请求
	@RequestMapping("myDeleteTest")
	public ModelAndView deleteCategory(Category category){
		categoryService.delete(category);
		ModelAndView mav = new ModelAndView("redirect:/listCategory");
		return mav;
	}	
	
	// 处理编辑分类的请求
	@RequestMapping("editCategory")
	public ModelAndView editCategory(Category category){
		Category c= categoryService.get(category.getId());
		ModelAndView mav = new ModelAndView("editCategory");
		mav.addObject("c", c);
		return mav;
	}	
	
	// 处理更新分类的请求
	@RequestMapping("updateCategory")
	public ModelAndView updateCategory(Category category){
		categoryService.update(category);
		ModelAndView mav = new ModelAndView("redirect:/listCategory");
		return mav;
	}	

}

查看运行效果：

增加：
在这里插入图片描述

删除：
在这里插入图片描述

修改：

在这里插入图片描述

7.Maven使用初体验：

（1）如何标准Maven-Web工程：

File—>New—>Other—>Maven Project—>NextX2，到达如下图所示界面，选择最后一个选项，webapp
在这里插入图片描述

设置当前Maven工程的三维坐标：

Group Id：
Artifact Id:
Version:

在这里插入图片描述

修改Properties，调整至使用计算机的默认jdk（1.8），如图所示

在这里插入图片描述
Apply，显示正常的Maven-Web项目结构：

（2）用Maven自动添加jar：

按照how2j将文件导入对应文件夹后，修改pom.xml，使它为我们管理项目所依赖的jar包，代码如下：

<!-- 定义项目的命名空间 -->
<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/xsd/maven-4.0.0.xsd">  <!-- 指定项目的schema -->
  <modelVersion>4.0.0</modelVersion>  <!-- 指定项目模型版本 -->
  <groupId>com.how2java</groupId>  <!-- 指定项目的groupId -->
  <artifactId>ssm</artifactId>  <!-- 指定项目的artifactId -->
  <version>0.0.1-SNAPSHOT</version>  <!-- 指定项目的版本号 -->
  <packaging>war</packaging>  <!-- 指定项目的打包方式 -->

  <properties>  <!-- 定义项目的公共属性 -->
    <spring.version>4.1.3.RELEASE</spring.version>  <!-- 定义Spring框架的版本号 -->
    <pagehelper.version>5.1.2-beta</pagehelper.version>  <!-- 定义PageHelper插件的版本号 -->
    <mysql.version>5.1.6</mysql.version>  <!-- 定义MySQL数据库驱动的版本号 -->
    <mybatis.spring.version>1.2.3</mybatis.spring.version>  <!-- 定义MyBatis Spring集成的版本号 -->
    <mybatis.version>3.1.1</mybatis.version>  <!-- 定义MyBatis的版本号 -->
    <junit.version>4.12</junit.version>  <!-- 定义JUnit的版本号 -->
    <jstl.version>1.2</jstl.version>  <!-- 定义JSTL的版本号 -->
    <jsqlparser.version>1.0</jsqlparser.version>  <!-- 定义jsqlparser的版本号 -->
    <jackson.version>1.2.7</jackson.version>  <!-- 定义Jackson的版本号 -->
    <servlet-api.version>3.1.0</servlet-api.version>  <!-- 定义Servlet API的版本号 -->
    <druid.version>1.0.18</druid.version>  <!-- 定义Druid数据源的版本号 -->
    <log4j.version>1.2.16</log4j.version>  <!-- 定义Log4j的版本号 -->
    <commons-logging.version>1.2</commons-logging.version>  <!-- 定义Commons Logging的版本号 -->
    <commons-fileupload.version>1.2.1</commons-fileupload.version>  <!-- 定义Commons FileUpload的版本号 -->
    <commons-io.version>1.3.2</commons-io.version>  <!-- 定义Commons IO的版本号 -->
    <commons-lang.version>2.6</commons-lang.version>  <!-- 定义Commons Lang的版本号 -->
    <aopalliance.version>1.0</aopalliance.version>  <!-- 定义AOP Alliance的版本号 -->
    <mybatis-generator.version>1.3.5</mybatis-generator.version>  <!-- 定义MyBatis Generator的版本号 -->
  </properties>

  <dependencies>  <!-- 定义项目的依赖 -->
    <dependency>  <!-- 定义JUnit的依赖 -->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
    </dependency>

    <dependency>  <!-- 定义MyBatis的依赖 -->
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>

    <dependency>  <!-- 定义MyBatis Spring集成的依赖 -->
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>

    <dependency>  <!-- 定义MySQL数据库驱动的依赖 -->
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <dependency>  <!-- 定义Druid数据源的依赖 -->
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>${druid.version}</version>
    </dependency>

    <dependency>  <!-- 定义Spring框架的依赖 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>  <!-- 定义Spring测试框架的依赖 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>  <!-- 定义Spring框架的依赖 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>  <!-- 定义Spring MVC框架的依赖 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>  <!-- 定义Spring JDBC框架的依赖 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>  <!-- 定义Spring AOP框架的依赖 -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>  <!-- 定义JSTL的依赖 -->
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl.version}</version>
    </dependency>

    <dependency>  <!-- 定义Servlet API的依赖 -->
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet-api.version}</version>
      <scope>provided</scope>
    </dependency>

    <dependency>  <!-- 定义PageHelper插件的依赖 -->
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>${pagehelper.version}</version>
    </dependency>

    <dependency>  <!-- 定义jsqlparser的依赖 -->
      <groupId>com.github.jsqlparser</groupId>
      <artifactId>jsqlparser</artifactId>
      <version>${jsqlparser.version}</version>
    </dependency>

    <dependency>  <!-- 定义Log4j的依赖 -->
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <dependency>  <!-- 定义Commons Logging的依赖 -->
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>${commons-logging.version}</version>
    </dependency>

    <dependency>  <!-- 定义Commons FileUpload的依赖 -->
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>${commons-fileupload.version}</version>
    </dependency>

    <dependency>  <!-- 定义Commons IO的依赖 -->
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>${commons-io.version}</version>
    </dependency>

    <dependency>  <!-- 定义Commons Lang的依赖 -->
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>${commons-lang.version}</version>
    </dependency>

    <dependency>  <!-- 定义AOP Alliance的依赖 -->
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>${aopalliance.version}</version>
    </dependency>

    <dependency>  <!-- 定义MyBatis Generator的依赖 -->
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>${mybatis-generator.version}</version>
    </dependency>

  </dependencies>

  <build>  <!-- 定义项目的构建配置 -->
    <finalName>${project.artifactId}</finalName>  <!-- 定义构建后的文件名 -->
    <plugins>  <!-- 定义构建插件 -->
      <plugin>  <!-- 定义资源文件拷贝插件 -->
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.7</version>
        <configuration>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
      <plugin>  <!-- 定义Java编译插件 -->
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
    <pluginManagement>  <!-- 定义插件管理 -->
      <plugins>
        <plugin>  <!-- 配置Tomcat插件 -->
          <groupId>org.apache.tomcat.maven</groupId>
          <artifactId>tomcat7-maven-plugin</artifactId>
          <version>2.2</version>
        </plugin>
      </plugins>
    </pluginManagement>

   <!-- 定义资源文件夹 -->
<resource>
  <!-- 指定资源文件夹路径 -->
  <directory>src/main/resources</directory>
  <!-- 指定需要包含的资源文件类型 -->
  <includes>
    <include>**/*.properties</include>
    <include>**/*.xml</include>
    <include>**/*.tld</include>
  </includes>
  <!-- 是否需要进行过滤 -->
  <filtering>false</filtering>
</resource>

<!-- 定义另一个资源文件夹 -->
<resource>
  <!-- 指定资源文件夹路径 -->
  <directory>src/main/java</directory>
  <!-- 指定需要包含的资源文件类型 -->
  <includes>
    <include>**/*.properties</include>
    <include>**/*.xml</include>
  </includes>
  <!-- 是否需要进行过滤 -->
  <filtering>false</filtering>
</resource>

  </build>


</project>