SSM+Maven+Redis框架学习

理论及实例介绍

1、Maven理论：

Maven是apache下的开源项目，Maven主要服务于基于Java平台的项目构建、依赖管理和项目信息管理。

　　1.1、Maven的几个核心概念

　　　　1.1.1、POM(Project Object Model)

　　　　一个项目所有的配置都放在POM文件中：定义项目的类型、名字、管理依赖关系，定制插件的行为等等。看下我自己写的小demo中pom中配置如下：

　　　　

　　　　在POM中，groupId、artifactId、packaging、version叫做maven坐标，它能唯一的确定一个项目。有了maven坐标，我们就可以用它来指定我们的项目所依赖的其他项目、插件、或者父项目。

　　　　1.1.2、Maven插件　　

　　　　Maven常用的插件比如compiler插件、surefire插件、jar插件。比如说jar插件包含建立jar文件的目标，compiler插件包含编译源代码和单元测试代码的目标，surefire插件则是运行单元测试的目标。为什么需要这些插件呢？因为maven本身不会做太多的事情，它不知道怎么样编译或者怎么样打包。它把构建的任务交给插件去做。插件定义了常用的构建逻辑，能够被重复利用。这样做的好处是，一旦插件有了更新，那么所有maven用户都能得到更新。

　　　　1.1.3、Maven生命周期

 　　　　生命周期指项目的构建过程，它包含了一系列的有序的阶段，而一个阶段就是构建过程中的一个步骤，比如package阶段、compiler阶段等。那么生命周期阶段和上面说的插件目标之间是什么关系呢？插件目标可以绑定到生命周期阶段上，一个生命周期可以绑定多个插件目标。当maven在构建过程中逐步的通过每个阶段时，会执行该阶段所有的插件目标。目前生命周期阶段有clean、vavidate、compiler、test、package、verify、install、site、deploy阶段。

　　　　1.1.4、Maven依赖关系

　　　　实际开发中我们会有复杂多的依赖关系，因为被依赖的jar文件会有自己的依赖关系，那么我们是不是也得把间接依赖的jar文件也都定义在POM中呢？答案是不需要，因为maven提供了传递依赖的特性，会把依赖的jar文件它所依赖的库也自动添加进来。

　　　　1.1.5、Maven库

　　　　Maven仓库分为中央仓库、本地仓库以及私服库：

　　　　　　1.1.5.1、中央仓库：

　　　　　　中央仓库就是远程仓库，仓库中jar由专业团队（maven团队）统一维护。中央仓库的地址：http://repo1.maven.org/maven2/

　　　　　　1.1.5.2、本地仓库：

　　　　　　相当于缓存，工程第一次会从远程仓库（互联网）去下载jar 包，将jar包存在本地仓库（电脑上的某个文件夹）。第二次不需要从远程仓库去下载。先从本地仓库找，如果找不到才会去远程仓库找。

　　　　　　1.1.5.3、私服：

　　　　　　在公司内部架设一台私服，其它公司架设一台仓库，对外公开。

2、Maven安装及使用：

　　第一步：下载maven

　　　　maven下载地址：http://maven.apache.org/download.cgi，apache-maven-3.5.2.bin.zip即可，将maven下载到本地并解压。

　　　　注意：安装maven之前需要安装jdk,maven3以上的版本要求jdk7以上

　　第二步：配置环境变量

　　　　右键“我的电脑”属性-> "高级"下面的"环境变量"->"新建"，变量填MAVEN_HOME 值填写你maven的解压目录，将路径复制过去即可，配置path 值填写 %MAVEN_HOME%\bin;

　　第三步：验证是否安装成功

　　　　打开CMD命令行，输入mvn  -v

　　　　

　　　　看到jdk和maven的安装路径即表示安装成功

　　第四步：修改配置

　　　　到%MAVEN_HOME%\conf目录下，找到并打开settings.xml配置文件，找到< localRepository>标签，修改本地仓库地址：

　　　　 

　　　　找到< mirror>，配置maven镜像：

　　　 

　　　　这个可以看作远程仓库或者中央仓库，由于maven中的jar下载是从网络中下载所以有时候网不好的时候就会出现下载速度过慢带来的不便利。镜像的配置作用就是选择jar下载的来源，我们一开始默认是使用国外的镜像，所以难免会出现网络不好的情况，访问外网本身就可能不快，这里配置的是国内阿里的镜像仓库，这个仓库是比较好的，下载jar速度还是很快的。

　　第五步：配置IDE（这里用的是IDEA）

　　 

　　如上图配置，选择本地maven仓库

 　　

　　如上图配置，

　　1：表示IDEA 会实时监控项目的 pom.xml 文件，进行项目变动设置。

　　2：表示VM参数和jdk版本。

　　3：表示Maven 导入依赖包的时候是否自动下载源码和文档。

3、Maven创建Java WEB项目：

　　第一步：如下图

 　　

　　第二步：如下图

 　　　

　　这三个属性目的是标识你的项目的唯一性

　　第三步：点击“Next”，然后“Finish”

　　项目创建好之后，点击右下角的 “Auto-Import” 　　

　　

　　第四步：创建好之后的目录结构如下图：

 　　

　　第五步：项目配置，如下图：

 　　

　　

　　Modules:可看到此项目无任何适配服务组件（因为是手工创建Maven，没有选择任何Maven模板）--因此需要我们进行添加。

 　　　

　　选择Web（为此项目添加Web服务组件，这便是一个Web项目了）

 　　

　　选择“main”目录

　　

　　在后面加上webapp。好了，点OK，Web的资源目录便设置好了。

 　　下面设置web的描述文件目录：（设置在webapp目录下）

 　　

　　Aftifacts: 这个Aftifacts描述了当前项目发布的信息。现在进行添加，从Modeles中选择。

 　　

　　

　　说明：1: 现在Artifacts已有了发布的项目了（idea中准确的说应是Modele） 2：output root目录描述了当前项目的编译目录及适配服务。

　　确定之后当前项目的结构：

 　　

　　第六步：项目部署，如下图：

 　　

　　添加Tomcat服务器：

　　

　　部署：

　　

　　

　　注：若找不到Arifact，请参考部署项目中的Modules的配置。如果没有为项目配置Web服务组件，那么就没有Artifact。（当前项目连Web项目都不是，哪儿来的Artifact，又部署什么呢？）

　　修改idea服务的热部署：

 　　　　

　　On Update action （当代码改变的时候，需要IDEA为你做什么）里面有四个选项（一般选Update classes and resources）：

    　　-Update resources ：如果发现有更新，而且更新的是资源文件（*.jsp，*.xml等，不包括java文件）,就会立刻生效

    　　-Update classes and resources ： 如果发现有更新，这个是同时包含java文件和资源文件的，就会立刻生效

       　 这里需要注意一下：在运行模式下，修改java文件时不会立刻生效的；而debug模式下，修改java文件时可以立刻生效的。当然，两种运行模式下，修改resources资源文件都是可以立刻生效的。

    　　-Redploy ： 重新部署，只是把原来的war删掉，不重启服务器

    　　-Restart ： 重启服务器

　　On Frame deactivation：（当失去焦点[比如你最小化了IDEA窗口]，需要IDEA为你做什么）

     　　-Do nothing : 不做任何事 （一般推荐这个，因为失去焦点的几率太大）

     　　-Update resources : 失去焦点后，修改的resources文件都会立刻生效

    　　-Update classes and resources ： 失去焦点后，修改的java ，resources文件都会立刻生效（与On update action中的Update classes and resources一样，也是运行模式修改的java文件不会生效，debug模式修改的java文件会立刻生效）

 　　

　　在Modules中加入tomcat依赖：

 　　

　　

　　

　　至此在idea开发工具中搭建的Maven Web项目已初步完成

 

4、Redis理论：

　　4.1、简介：

 　　Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它通常被称为数据结构服务器，因为值（value）可以是字符串(String), 哈希(Map), 列表(list), 集合(sets) 和有序集合(sorted sets)等类型。　

　　4.2、特点：

 　　Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

　　Redis 与其他 key - value 缓存产品有以下三个特点：

 　　　　Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。

 　　　　Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

 　　　　Redis支持数据的备份，即master-slave模式的数据备份。

　　4.3、优势：

 　　性能极高–Redis能读的速度是110000次/s,写的速度是81000次/s。

 　　丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。

 　　原子 – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。

 　　丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

　　4.4、缓存策略：

　　Redis和数据库结合使用，使用策略如下

　　　　4.4.1、读取数据

 　　　　

　　　　4.4.2、更新数据（常用数据，变动性不强，并发不高）

 　　　　

　　　　4.4.3、更新数据（并发较高）

 　　　　

5、Redis实例：　

　　5.1、jar包导入：

 　　

　　

　　Java使用redis需导入jedis和spring-data-redis这两个jar包，因为spring与redis可以完美整合，所有这里需注意spring、jedis和spring-data-redis的版本，版本不一致运行时会异常。经过调试以上版本可以使用。

　　5.2、Spring与Redis集成配置文件：

 　　以下是redis连接池和jedis的配置

　　

　　　redis注入

　　

　　5.3、定义redisDao接口和实现类：

 　　

　　

6、SSM理论：

　　SSM框架，是Spring+SpringMVC+Mybatis的缩写，是继承SSH框架之后，目前比较主流的Java EE企业级框架，适用于搭建各种大型的企业级的应用系统

　　6.1、Spring：

　　Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 简单来说，Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架

　　　　6.1.1、控制反转（IOC）是什么？

　　　　IOC:控制反转也叫依赖注入。利用了工厂模式将对象交给容器管理，你只需要在spring配置文件总配置相应的bean，以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些bean分配给你需要调用这些bean的类（假设类名是A），分配的方法就是调用A的setter方法来注入，而不需要你在A里面new这些bean了

　　　　

　　　　

　　　　6.1.2、面向切面（AOP）是什么？

 　　　　首先，需要说明的一点，AOP只是Spring的特性，它就像OOP一样是一种编程思想，并不是某一种技术,AOP可以说是对OOP的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。将程序中的交叉业务逻辑（比如安全，日志，事务等），封装成一个切面，然后注入到目标对象（具体业务逻辑）中去

 　　　　

　　　　自定义一个“操作日志”的注解

 　　　　

　　　　定义一个切面类

 　　　　

　　　　

　　6.2、SpringMVC：

 　　Spring MVC属于Spring Framework的后续产品，已经融合在Spring Web Flow里面，它原生支持的Spring特性，让开发变得非常简单规范。Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制

 　　下面这个是它主要的工作原理图：

 　　

　　6.3、Mybatis：

　　MyBatis本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。MyBatis是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。可以这么理解，MyBatis是一个用来帮你管理数据增删改查的框架。

 　　他的结构如下图所示：

　　

7、SSM实例：

　　7.1、第一步：

 　　在maven的pom.xm配置文件中定义SSM所需要的jar包及版本

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.yiwei.devManager</groupId>
    <artifactId>DevManager</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>DevManager</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- spring版本号 -->
        <spring.version>4.0.2.RELEASE</spring.version>
        <!-- MyBatis版本号 -->
        <mybatis.version>3.4.2</mybatis.version>
        <!-- log4j日志文件管理包版本号 -->
        <slf4j.version>1.7.7</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <jedis.version>2.9.0</jedis.version>
        <spring.data.redis.version>1.7.1.RELEASE</spring.data.redis.version>
        <hibernate-validator.version>5.3.4.Final</hibernate-validator.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.servlet.jsp.jstl</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <!-- 表示开发的时候引用，发布的时候不会加载此包 -->
            <scope>test</scope>
        </dependency>

        <!-- spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring/redis -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

        <!-- mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- mybatis/spring包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

        <!-- javaee jar包 -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>

        <!-- mysql数据库连接jar包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.30</version>
        </dependency>

        <!-- jdbc jar包，用来在applicationContext.xml中配置数据库 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>

        <!-- JSTL标签类 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- 日志文件管理包 -->
        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!-- 格式化对象，方便输出日志 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->

        <!-- JSON -->
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.2.3</version>
            <classifier>jdk15</classifier>
        </dependency>

        <!-- 上传组件包 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.9</version>
        </dependency>

        <!-- mqtt paho -->
        <dependency>
            <groupId>org.eclipse.paho</groupId>
            <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
            <version>1.2.0</version>
        </dependency>

        <!-- redis start -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${jedis.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>${spring.data.redis.version}</version>
        </dependency>
        <!-- redis end -->

        <!-- 参数认证 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate-validator.version}</version>
        </dependency>

        <!-- aspectj AOP -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.10</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <!-- 自动生成mybatis文件的插件 -->
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

　　7.2、第二步：

　　　　7.2.1、定义项目的目录结构

 　　　　

　　　　7.2.2、首先看MVC的架构：

　　　　　　7.2.2.1、Model：

 　　　　　　entity就是MVC架构中的模型（Model）层，这里是普通的Java对象（POJO），主要作用就是数据的临时存储，这个UserInfo对象一般和数据库中的UserInfo表结构保持一致

 　　　　　　

　　　　　　7.2.2.3、View：

 　　　　　　webapp下面的.jsp、.html文件就是视图（View）层

 　　　　　　

　　　　　　7.2.2.4、Controller：

 　　　　　　

　　　　　　可以看到是用注解的方式在代码中来声明这是一个控制器@Controller，用@Autowired来自动实例化这个UserDao的对象（这就是刚才说到的控制反转），而第二个@RequestMapping表示的是这个方法的入口。最后，这个控制器通过返回ModelAndView对象到视图。

　　　　　　7.2.2.5、数据库访问层

　　　　　　　　7.2.2.5.1、Mapper：

 　　　　　　　　

　　　　　　　　7.2.2.5.2、DAO：

 　　　　　　　　

　　　　　　　　7.2.2.5.3、Service：

 　　　　　　　　

　　　7.2.3、然后看resources目录下的配置文件：

 　　　　jdbc.properties：

　　　　log4j.properties：日志配置文件

 　　　　redis.properties：

　　　　spring的配置：Spring-mybatis.xml、spring-redis.xml

　　　　springMVC的配置：spring-mvc.xml

　　　　mybatis文件夹里是mybatis对数据库操作的映射文件

 　　　　最后，再说一下，JavaEE工程中，所有请求的入口来源都是web.xml这个文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <display-name>Archetype Created Web Application</display-name>
    <!-- Spring和Mybatis的配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mybatis.xml, classpath:spring-redis.xml</param-value>
    </context-param>
    <!-- 编码过滤器 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <async-supported>true</async-supported>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 用cors解决前后端分离的跨域问题过滤器 -->
    <filter>
        <filter-name>corsFilter</filter-name>
        <filter-class>com.yiwei.filter.CorsFilter</filter-class>
        <init-param>
            <param-name>allowOrigin</param-name>
            <param-value>http://localhost:8080</param-value>
        </init-param>
        <init-param>
            <param-name>allowMethods</param-name>
            <param-value>>GET,POST,PUT,DELETE,OPTIONS</param-value>
        </init-param>
        <init-param>
            <param-name>allowCredentials</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>allowHeaders</param-name>
            <param-value>Content-Type,X-Token</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>corsFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 用来过滤rest中的方法，在隐藏域中的put/delete方式,注意 由于执行顺序原因  一定要放在编码过滤器下面，否则会出现编码问题 -->
    <filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
        <init-param>
            <param-name>methodParam</param-name>
            <param-value>_method</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- Spring监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 防止Spring内存溢出监听器 -->
    <listener>
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    </listener>

    <listener>
        <listener-class>com.yiwei.listener.Listener</listener-class>
    </listener>
    
    <!-- Spring MVC Servlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <!-- 此处可以配置成*.do，对应Struts的后缀习惯 -->
        <!-- 第一种： *.action，所有以*.action结尾的访问，都由DispatcherServlet解析
         第二种：/ ，所有访问的地址都由DispatcherServlet解析，对于这种配置会出现一个问题，那就是静态文件的访问不需要，DispatcherServlet进行解析（因为访问静态文件直接返回即可，不用再由处理器处理）。但是这种方式可以实现RESTful风格的url
         第三种：/* ，这种配置不对，使用这种配置，最终要转发到一个jsp页面时，仍然会由DispatcherServlet解析jsp的地址，不能根据jsp的页面找到Handler，会报错-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <welcome-file-list>
        <welcome-file>/login.jsp</welcome-file>
    </welcome-file-list>

</web-app>

转载于:https://www.cnblogs.com/zl-wjzf/p/9414225.html