SpringMvc+MyBatis+MySQL+Maven+Redis搭建一个基础的web项目

短命女 2022-06-13 02:30 58阅读 0赞

*   *   *  前言
         *  软件安装及资源配置
            
             *  JDK安装
             *  MyEclipse10安装及破解
             *  Maven安装及配置
             *  MySQL下载及安装
             *  Tomcat下载及安装
             *  Redis下载及安装
         *  项目搭建
            
             *  项目创建
             *  数据库基础数据准备
             *  插件配置
             *  代码编写
             *  单元测试
         *  总结

### **前言** ###

近来由于公司项目的需要，暂时放下了前端android的开发，慢慢投入到后台接口系统搭建，在经过与众兄弟的讨论下，决定就使用最常规的框架去搭建一个后台接口系统，这样一方面大家都比较的熟悉，另一方面对于新人和后期的维护都会相对比较容易一些，因此，针对这一系列框架最基础的搭建，在此做一个简单的总结，希望能对这一块儿还相对陌生的猿猿能有所帮助

先上源码，[点击下载][Link 1]  
阅读请参考博客：[SpringMvc+MyBatis+MySQL+Maven+Redis搭建一个基础的web项目][SpringMvc_MyBatis_MySQL_Maven_Redis_web]

### **软件安装及资源配置** ###

#### **JDK安装** ####

*  **jdk下载**  
    [jdk1.8下载][jdk1.8]之后，安装；
 *  **环境变量配置**  
    
    
     *  “我的电脑”–>右键–>属性–>高级系统设置–>环境变量–>系统变量–>新建–>添加一项“JAVA\_HOME”路径为jdk的安装路径，如下图：  
        ![SouthEast][]
     *  然后path中添加 **%JAVA\_HOME%\\bin;%JAVA\_HOME%\\jre\\bin;**,如下图：  
        ![SouthEast 1][]
     *  测试  
        cmd下输入：java -version 如下图效果说明安装成功  
        ![SouthEast 2][]

--------------------

#### **MyEclipse10安装及破解** ####

*  **资源下载**  
    [MyEclipse10及破解工具下载入口][MyEclipse10]
 *  **安装及破解**  
    MyEclipse的安装就是next next…finish即可；其中破解工具打开软件日志栏中写有相应的教程，请参考教程步骤；一步步破解，这是我目前发现最好用的一个破解工具。

--------------------

#### **Maven安装及配置** ####

（根据个人需要；可用可不用）  
\- **资源下载**  
[maven-3.2.1版本下载][maven-3.2.1]  
\- **解压压缩包**  
如下图：  
![SouthEast 3][]  
\- **配置环境变量**  
\- 如第一步中配置jdk一样，进入到环境变量配置页面  
\- 添加“MAVEN\_HOME”配置解压后maven的路径  
如下图：  
![SouthEast 4][]  
\- 将maven路径指定到path下  
如下图：  
![这里写图片描述][SouthEast 5]  
\- **测试**  
打开cmd （如果还是之前测试jdk的cmd窗口，请关闭了重新打开）输入：mvn -v 如果出现以下效果，说明已经安装成功：  
![SouthEast 6][]  
\- **调整maven的配置文件**  
\- 找到解压路径下的conf文件，进去找到setting.xml配置文件  
\- 将该配置文件拷贝至“C:\\Users\\Administrator.m2”路径下  
配置到这里的目的是为了以后我们更新了maven的版本之后，不需要出现配置setting文件，至需要更换一下环境变量即可，如下图：  
![SouthEast 7][]  
\- 打开setting文件，找到“localRepository”配置自己本机maven仓库的路径（根据个人习惯配置），如果不配置这个路径，默认会在将以下路径“C:\\Users\\Administrator.m2\\repository“作为Maven仓库  
![SouthEast 8][]  
\- **Myeclipse配置Maven**  
打开MyEclipse，选择**Window–>Preferences–>Maven4MyEclipse–>User Settings**,配置上一步中修改的settings.xml文件，如下图:  
![SouthEast 9][]

--------------------

#### **MySQL下载及安装** ####

*  **资源下载**  
    [MySQL安装版、免安装版及Navicat破解版下载][MySQL_Navicat]
 *  **安装**  
    
    
     *  **MySQL安装版安装**  
        以上链接中下载MySQL安装版，解压，安装，然后next next …finish即可
     *  **免安装版安装**  
        请参考之前的博客[MySQL安装及可视化工具使用][MySQL]
     *  **Navicat（MySQL）可视化工具安装及破解**  
        下载以上链接中Navicat工具，根据个人电脑的情况选择32位或者64位的安装；安装完之后运行”patchNavicat.exe”即可完成工具破解

--------------------

#### **Tomcat下载及安装** ####

*  **资源下载**  
    [Tomcat 7.0资源下载][Tomcat 7.0]；rar和exe文件为安装版tomcat，zip包为免安装版tomcat；根据需要下载相应的文件；演示选择的exe安装版。
 *  **Tomcat安装**  
    老规矩，next next.. finish即可;安装路径最好不要出现空格在里面；隐隐约约记得好像Tomcat的全路径中有空格在什么地方是会有问题；具体什么问题也记不清了；也可能是我记错了；唠叨一句，选择一个不含空格的路径安装；以防万一。
 *  **MyEclipse配置Tomcat**  
    打开MyEclipse,选择Window–>Preferences–>MyEclipse–>service–>Tomcat 7.x;按如下图配置上面步骤中安装的路径；  
    ![SouthEast 10][]  
    注:记得要勾选上“Enable”选项，否则这个配置将不会生效；
 *  **测试Tomcat**  
    
    
     *  **启动服务**  
        按下图步骤启动服务，见日志栏中出现下图中的日志，说明服务启动成功；  
        ![SouthEast 11][]
     *  **浏览器测试**  
        浏览器中输入：localhost:8080；如出现如下效果，说明tomcat配置成功；  
        ![SouthEast 12][]

--------------------

#### **Redis下载及安装** ####

（根据个人需要，redis可用可不用）  
可参考资料[Redis安装][Redis]

*  **资源下载**  
    [Redis-x64-3.2.100][]下载，并解压安装包
 *  **启动服务**  
    cmd下进入解压目录，输入：redis-server.exe redis.windows.conf；见到如下图效果，说明服务已经启动成功了。  
    ![SouthEast 13][]
 *  **redis客户端测试**  
    新起一个cmd窗口（注意上面的服务cmd窗口不要关闭了）；输入：redis-cli.exe -h 127.0.0.1 -p 6379 链接到本地redis的服务；通过set、get指令测试存取值正常；如下图：  
    ![SouthEast 14][]

### 项目搭建 ###

#### 项目创建 ####

*  创建maven项目
    
     *  项目搭建  
        右键–>New–>Web Project；输入项目名，**选择j2ee 6.0，勾选上Add Maven support**，点击finish，如下图  
        ![SouthEast 15][]
     *  创建成功之后为如下结构:  
        ![SouthEast 16][]
 *  项目结构调整
    
     *  创建基础的资源配置、测试代码、测试资源配置文件夹  
        右键–>build Path–>New Source Folder  
        ![SouthEast 17][]  
        或者右键–>New–>Source Folder  
        ![SouthEast 18][]  
        然后分别创建**“src/main/resources”、”src/test/java”、”src/test/resources”** 如下图:  
        ![SouthEast 19][]
 *  整理代码及资源配置文件结构  
    ![SouthEast 20][]  
    按以上结构分别创建文件夹即可

#### 数据库基础数据准备 ####

*  创建一个简单的用户表，用户测试即可，如下图：  
    ![SouthEast 21][]  
    创建脚本如下
    
        Date: 2017-07-02 19:20:45
        */
        
        SET FOREIGN_KEY_CHECKS=0;
        
        -- ----------------------------
        -- Table structure for userinfo
        -- ----------------------------
        DROP TABLE IF EXISTS `userinfo`;
        CREATE TABLE `userinfo` ( `ID` int(11) NOT NULL AUTO_INCREMENT, `NAME` varchar(20) NOT NULL, `AGE` int(5) DEFAULT NULL, `SEX` int(1) DEFAULT NULL, `ADD` varchar(255) DEFAULT NULL, PRIMARY KEY (`ID`) ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
        
        -- ----------------------------
        -- Records of userinfo
        -- ----------------------------
        INSERT INTO `userinfo` VALUES ('1', '张三', '10', '0', '北京');
        INSERT INTO `userinfo` VALUES ('2', '李四', '20', '1', '上海');
        INSERT INTO `userinfo` VALUES ('3', '赵五', '23', '1', '广州');
        INSERT INTO `userinfo` VALUES ('4', '钱六', '50', '0', '台湾');

#### **插件配置** ####

*  **Maven的pom.xml配置**
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            
            <spring.version>3.2.8.RELEASE</spring.version>
            
            <slf4j.version>1.6.6</slf4j.version>
            <log4j.version>1.2.12</log4j.version>
            
            <junit.version>4.10</junit.version>
            
            <mybatis.version>3.2.1</mybatis.version>
        </properties>
        
        <dependencies>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</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-context</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-aop</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</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-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
        
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        
            
            
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</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>
            
        
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
                <scope>test</scope>
            </dependency>
        
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
        
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.2.0</version>
            </dependency>
        
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.29</version>
            </dependency>
        
            
            <dependency>
                <groupId>javax</groupId>
                <artifactId>javaee-api</artifactId>
                <version>6.0</version>
                <scope>provided</scope>
            </dependency>
        
            
            <dependency>
                <groupId>javax</groupId>
                <artifactId>javaee-web-api</artifactId>
                <version>6.0</version>
                <scope>provided</scope>
            </dependency>
        
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.7.4</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>2.7.4</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-annotations</artifactId>
                <version>2.7.4</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.32</version>
            </dependency>
        
            
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>1.3.0.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.6.2</version>
            </dependency>
        </dependencies>
    
    添加成功保存，Maven会自动下载相应的对应版本的包到本地仓库；由于部分资源包在不同的网络环境下下载会比较慢，如果Maven下载不下来，我在百度云盘共享了一份上面各个版本对应的包，可以下载下来解压到本地的仓库即可使用；[点击下载][Link 2]
 *  **MyBatis配置**
    
     *  jdbc属性配置文件  
        在properties文件夹下创建jdbc.properties，并配置以下参数：
        
            jdbc_driverClassName=com.mysql.jdbc.Driver
            jdbc_url=jdbc:mysql://127.0.0.1:3306/springmvcdb
            jdbc_username=lpf
            jdbc_password=123456
     *  mybatis配置  
        这里直接配置在application.xml；请参考后续的applocation配置
 *  **redis配置**
    
     *  redis参数配置文件  
        在redis文件夹下创建redis.properties，添加如下参数：
        
            redis.pool.maxTotal=105
            redis.pool.maxIdle=10
            redis.pool.maxWaitMillis=5000
            redis.pool.testOnBorrow=true
            redis.host=127.0.0.1
            redis.port=6379
            redis.password=
            redis.db.index=0
     *  redis基础配置  
        在redis下创建redis-config.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"
                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.xsd">
            
                
                <context:component-scan base-package="com.lpf.springmvc" />
                
                
            
                
                <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
                    <property name="maxTotal" value="${redis.pool.maxTotal}" />
                    <property name="maxIdle" value="${redis.pool.maxIdle}" />
                    <property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}" />
                    <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
                </bean>
            
                <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
                    <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
                    <constructor-arg name="host" value="${redis.host}" />
                    <constructor-arg name="port" value="${redis.port}" type="int" />
                    <constructor-arg name="timeout" value="${redis.pool.maxWaitMillis}" type="int" />
                    <constructor-arg name="password" value="#{'${redis.password}'!=''?'${redis.password}':null}" />
                    <constructor-arg name="database" value="${redis.db.index}" type="int" />
                </bean>
            
                
                
            
                
                
            
                
                <bean id="jedisConnectionFactory"
                    class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
                    <property name="hostName" value="${redis.host}" />
                    <property name="port" value="${redis.port}" />
                    <property name="password" value="${redis.password}" />
                    <property name="poolConfig" ref="jedisPoolConfig" />
                </bean>
            
                
                <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
                    <property name="connectionFactory" ref="jedisConnectionFactory" />
                </bean>
            
            </beans>
     *  redis dao层相关配置
        
         *  接口定义  
            在Dao文件加下创建一个用于获取redis下数据的接口（以获取一个文本型的数据为例）
            
                package com.lpf.springmvc.dao;
                
                import org.springframework.stereotype.Repository;
                
                @Repository
                public interface RedisDao { 
                    String get(String key);
                }
         *  创建Jedis帮助对象  
            一个公共的帮助类，代码太长，放到网盘了，下载下来即可:[JedisUtil][]
         *  创建dao的具体实现  
            在dao文件下创建RedisDaoImpl，实现RedisDao接口，代码如下：  
            
            
                package com.lpf.springmvc.dao;
                
                import javax.annotation.Resource;
                
                import com.lpf.springmvc.utils.JedisUtil;
                
                import redis.clients.jedis.JedisPool;
                
                public class RedisDaoImpl implements RedisDao { 
                    @Resource
                    JedisPool jedisPool;
                
                    public String get(String key)
                    {
                        // TODO Auto-generated method stub
                        JedisUtil jedisUtil = new JedisUtil(jedisPool);
                        JedisUtil.Strings strings = jedisUtil.new Strings();
                        System.out.println("cache: " + strings.get(key));
                        return strings.get(key);
                    }
                
                }
    
    配置完成之后，为如下效果：  
    ![SouthEast 22][]
 *  **SpringMvc相关配置**
    
     *  springmvc基础配置  
        在springmvc文件夹下创建spring-mvc.xml，并配置以下代码  
        
        
            <?xml version="1.0" encoding="UTF-8"?>
            <beans xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" 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-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
            
                
                
                <mvc:annotation-driven>
                    <mvc:message-converters register-defaults="true">
                        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                            <property name="objectMapper">
                                <bean class="com.fasterxml.jackson.databind.ObjectMapper">
                                    <property name="serializationInclusion">
                                        <value type="com.fasterxml.jackson.annotation.JsonInclude.Include">NON_NULL</value>
                                    </property>
                                </bean>
                            </property>
                        </bean>
                    </mvc:message-converters>
                </mvc:annotation-driven>
            
                
                <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
                    <property name="messageConverters">
                        <list>
                            
                            <ref bean="mappingJacksonHttpMessageConverter" />
                        </list>
                    </property>
                </bean>
                <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
                    <property name="messageConverters">
                        <list>
                            <ref bean="mappingJacksonHttpMessageConverter" />
                        </list>
                    </property>
                </bean>
            
                <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                    <property name="supportedMediaTypes">
                        <list>
                            <bean class="org.springframework.http.MediaType">
                                <constructor-arg index="0" value="text" />
                                <constructor-arg index="1" value="plain" />
                                <constructor-arg index="2" value="UTF-8" />
                            </bean>
                            <bean class="org.springframework.http.MediaType">
                                <constructor-arg index="0" value="*" />
                                <constructor-arg index="1" value="*" />
                                <constructor-arg index="2" value="UTF-8" />
                            </bean>
                            <bean class="org.springframework.http.MediaType">
                                <constructor-arg index="0" value="text" />
                                <constructor-arg index="1" value="*" />
                                <constructor-arg index="2" value="UTF-8" />
                            </bean>
                            <bean class="org.springframework.http.MediaType">
                                <constructor-arg index="0" value="application" />
                                <constructor-arg index="1" value="json" />
                                <constructor-arg index="2" value="UTF-8" />
                            </bean>
                        </list>
                    </property>
                </bean>
            
                
                <context:component-scan base-package="com.lpf.springmvc.controller" />
            
                
                <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/WEB-INF/view/" p:suffix=".jsp" />
            </beans>
 *  **application.xml配置**  
    在配置文件根目录下创建一个application.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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        
            
            <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
                <property name="locations">
                    <list>
                        <value>classpath:properties/jdbc.properties</value>
                        <value>classpath:redis/redis.properties</value>
                        
                    </list>
                </property>
            </bean>
        
            
            <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
                
                <property name="driverClassName">
                    <value>${jdbc_driverClassName}</value>
                </property>
                <property name="url">
                    <value>${jdbc_url}</value>
                </property>
                <property name="username">
                    <value>${jdbc_username}</value>
                </property>
                <property name="password">
                    <value>${jdbc_password}</value>
                </property>
            </bean>
        
            
            <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
                <property name="basePackage" value="com.lpf.springmvc.dao" />
            </bean>
        
            
            <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
                <property name="dataSource" ref="dataSource" />
                <property name="mapperLocations" value="classpath*:com/lpf/springmvc/mapper/**/*.xml" />
                <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />
            </bean>
        
            
            <bean id="redisDao" class="com.lpf.springmvc.dao.RedisDaoImpl">
            </bean>
            <import resource="redis/redis-config.xml" />
        
            
            <context:component-scan base-package="com.lpf.springmvc.service" />
        
        </beans>
 *  **项目web.xml配置**  
    打开src–>main–>webapp–>WEB-INF–>web.xml，配置如下代码：
    
        <?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></display-name> 
          <welcome-file-list>
            <welcome-file>index.jsp</welcome-file>
          </welcome-file-list>
        
          <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:application.xml</param-value>
          </context-param>
          <context-param>
            <param-name>webAppRootKey</param-name>
            <param-value>springmvc.root</param-value>
          </context-param>
          <filter>
            <filter-name>SpringEncodingFilter</filter-name>
            <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
            <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>SpringEncodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
          </filter-mapping>
          <context-param>
            <param-name>log4jConfigLocation</param-name>
            <param-value>classpath:log4j.properties</param-value>
          </context-param>
          <context-param>
            <param-name>log4jRefreshInterval</param-name>
            <param-value>6000</param-value>
          </context-param>
          <listener>
            <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
          </listener>
          <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
          </listener>
          <servlet>
            <servlet-name>dispatcherServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
              <param-name>contextConfigLocation</param-name>
              <param-value>classpath:springmvc/spring-mvc.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
          </servlet>
          <servlet-mapping>
            <servlet-name>dispatcherServlet</servlet-name>
            <url-pattern>/</url-pattern>
          </servlet-mapping>
          <error-page>
            <error-code>404</error-code>
            <location>/WEB-INF/errorpage/404.jsp</location>
          </error-page>
          <error-page>
            <error-code>405</error-code>
            <location>/WEB-INF/errorpage/405.jsp</location>
          </error-page>
          <error-page>
            <error-code>500</error-code>
            <location>/WEB-INF/errorpage/500.jsp</location>
          </error-page>
        </web-app>
 *  配置简单测试  
    
    
     *  将项目发布到tomcat  
        ![SouthEast 23][]  
        ![SouthEast 24][]
     *  页面测试  
        打开浏览器，输入[http://localhost:8080/SpringMvc][http_localhost_8080_SpringMvc]；出现以下效果，说明基本的配置未编译出错  
        ![SouthEast 25][]

#### **代码编写** ####

主要用于梳理从前端–>controller–>service–>dao 处理完数据再回去的这么一个过程

*  dao层相关代码编写
    
     *  用户 信息dao层接口定义  
        定义2个方法,分别用于获取所有用户信息和根据id获取指定用户信息，代码如下
        
            package com.lpf.springmvc.dao;
            
            import java.util.List;
            
            import com.lpf.springmvc.model.UserInfo;
            
            /** * 操作用户消息的dao * @author lupf * */
            public interface UserInfoDao { 
                /** * 获取所有的用户 * @return */
                public List<UserInfo> getUserInfos();
            
                /** * 根據用戶id获取用户消息 * @param id * @return */
                public UserInfo getUserInfoByID(int id);
            }
     *  MyBatis mapper配置文件  
        添加用户信息相关的mapper配置文件，在mapper文件夹下创建user-info-mapper.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.lpf.springmvc.dao.UserInfoDao">
                
                <resultMap id="BaseResultMap" type="com.lpf.springmvc.model.UserInfo">
                    <id column="ID" property="id" jdbcType="INTEGER" />
                    <result column="NAME" property="name" jdbcType="VARCHAR" />
                    <result column="AGE" property="age" jdbcType="INTEGER" />
                    <result column="SEX" property="sex" jdbcType="INTEGER" />
                    <result column="ADD" property="add" jdbcType="VARCHAR" />
                </resultMap>
                
                <select id="getUserInfoByID" parameterType="int" resultMap="BaseResultMap">
                    SELECT * FROM userinfo WHERE ID = #{id}
                </select>
            
                
                <select id="getUserInfos" resultMap="BaseResultMap">
                    SELECT * FROM userinfo
                </select>
            </mapper>
 *  用户service配置
    
     *  定义service接口  
        用于获取用户信息的service，根本用来根据id获取和获取所以，service基本和到差不对匹配，但是不是绝对匹配
        
            package com.lpf.springmvc.service;
            
            import java.util.List;
            
            import com.lpf.springmvc.model.UserInfo;
            
            /** * 操作用户消息的service * * @author lupf * */
            public interface UserInfoService { 
                /** * 获取所有的用户 * * @return */
                public List<UserInfo> getUserInfos();
            
                /** * 根據用戶id获取用户消息 * * @param id * @return */
                public UserInfo getUserInfoByID(int id);
            
                /** * 根据redis的key获取redis的一个文本型value * @param key * @return */
                public String getValueByRedisKey(String key);
            }
     *  用户信息service的具体实现
        
            package com.lpf.springmvc.service;
            
            import java.util.List;
            
            import javax.annotation.Resource;
            
            import org.springframework.stereotype.Service;
            
            import com.lpf.springmvc.dao.RedisDao;
            import com.lpf.springmvc.dao.UserInfoDao;
            import com.lpf.springmvc.model.UserInfo;
            
            @Service
            public class UserInfoServiceImpl implements UserInfoService { 
                @Resource
                UserInfoDao userInfoDao;
            
                @Resource
                RedisDao redisDao;
            
                @Override
                public List<UserInfo> getUserInfos() {
                    // TODO Auto-generated method stub
                    return userInfoDao.getUserInfos();
                }
            
                @Override
                public UserInfo getUserInfoByID(int id) {
                    // TODO Auto-generated method stub
                    return userInfoDao.getUserInfoByID(id);
                }
            
                @Override
                public String getValueByRedisKey(String key) {
                    // TODO Auto-generated method stub
                    return redisDao.get(key);
                }
            
            }
    
    记住，需要在类上添加@Service的注解，service才会被自动注入进来；在service中引入dao，即可操作数据；
 *  用户信息controller
    
     *  view层代码编写  
        在WEB-INF下的view文件夹（该文件的路径在spring-mvc.xml中配置了）下添加一个用于获取了一个用户之后，绑定用户信息的user.jsp页面，代码如下：
        
            <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
            <html>
            <body>
            <h2>Hello World!</h2>
             编号:${user.id}<br>
             姓名:${user.name}<br>
             年龄:${user.age}<br>
             性别:${user.sex==0?"女":"男"}<br>
             地址:${user.add}<br>
            </body>
            </html>
     *  controller代码编写  
        主要用户和前段交互的入口，代码如下：
        
            package com.lpf.springmvc.controller;
            
            import java.util.List;
            
            import javax.annotation.Resource;
            
            import org.slf4j.Logger;
            import org.slf4j.LoggerFactory;
            import org.springframework.stereotype.Controller;
            import org.springframework.web.bind.annotation.RequestMapping;
            import org.springframework.web.bind.annotation.ResponseBody;
            import org.springframework.web.servlet.ModelAndView;
            
            import com.alibaba.fastjson.JSON;
            import com.lpf.springmvc.model.UserInfo;
            import com.lpf.springmvc.service.UserInfoService;
            
            @Controller
            public class UserInfoController {
                protected Logger logger = LoggerFactory.getLogger(getClass());
            
                @Resource
                UserInfoService userInfoService;
            
                @RequestMapping("/userInfo")
                public ModelAndView getUserInfoByID(int id) {
                    // 指定view层的页面,参数user即为对应的jsp的名称
                    ModelAndView mav = new ModelAndView("user");
                    if (id <= 0)
                        id = 1;
                    // 获取数据
                    UserInfo userInfo = userInfoService.getUserInfoByID(id);
                    // 将获取到的对象添加到ModelAndView对象中
                    mav.addObject("user", userInfo);
                    return mav;
                }
            
                @RequestMapping("/getUserInfos")
                @ResponseBody
                public List<UserInfo> getUserInfos() {
                    List<UserInfo> users = userInfoService.getUserInfos();
                    logger.info(""+JSON.toJSONString(users));
                    return users;
                }
            
            }
        
        RequestMapping指明了前端请求该方法的路径。如getUserInfoByID方法配置了userInfo这个注解，那么前段请求时候的路径即为：[http://localhost:8080/SpringMvc/userInfo][http_localhost_8080_SpringMvc_userInfo]
     *  getUserInfoByID方法解析  
        该方法主要用于前段jsp界面的请求；实例化的ModelAndView指明了绑定的view界面，上面方法中添加了 ;获取到数据添加到ModelAndView中即可自动绑定到相应的位置。  
        前端测试地址为:[http://localhost:8080/SpringMvc/userInfo?id=1][http_localhost_8080_SpringMvc_userInfo_id_1]；界面显示效果如下：  
        ![SouthEast 26][]  
        ![SouthEast 27][]
     *  getUserInfos方法解析  
        该接口主要用于给前端提供api接口时使用，添加了@ResponseBody即可，因为RequestMapping注解为getUserInfos；前端请求即以getUserInfos作为该方法的请求路径。  
        前端测试地址为:[http://localhost:8080/SpringMvc/getUserInfos][http_localhost_8080_SpringMvc_getUserInfos]；前端显示效果如下：  
        ![SouthEast 28][]

#### **单元测试** ####

针对上面service的具体实现，我们通过Junit进行一下单元测试；在没有前端的情况下即可完成接口的调试。

*  代码编写  
    在src/test/java目录下编写但愿测试代码
    
     *  创建测试代码的基类，代码如下：
        
            package com.lpf.springmvc.test;
            
            import org.junit.runner.RunWith;
            import org.slf4j.Logger;
            import org.slf4j.LoggerFactory;
            import org.springframework.test.context.ContextConfiguration;
            import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
            import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
            
            //指定bean注入的配置文件
            @ContextConfiguration(locations = { "classpath:application.xml" })
            // 使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner
            @RunWith(SpringJUnit4ClassRunner.class)
            public abstract class SpringTestCase extends AbstractJUnit4SpringContextTests { 
                protected Logger logger = LoggerFactory.getLogger(getClass());
            }
     *  编写service测试代码
        
            package com.lpf.springmvc.test;
            
            import java.util.List;
            
            import javax.annotation.Resource;
            
            import org.junit.Test;
            
            import com.alibaba.fastjson.JSON;
            import com.lpf.springmvc.model.UserInfo;
            import com.lpf.springmvc.service.UserInfoService;
            
            public class UserInfoTest extends SpringTestCase { 
                @Resource
                UserInfoService usersInfoService;
            
                @Test
                public void selectUserByIdTest() {
                    UserInfo user = usersInfoService.getUserInfoByID(1);
                    logger.debug("查找结果" + user);
                }
            
                @Test
                public void selectUserInfosTest() {
                    List<UserInfo> users = usersInfoService.getUserInfos();
                    logger.debug("查找结果" + JSON.toJSONString(users));
                }
            
                @Test
                public void getValueByRedisKey(){
                    String va  =usersInfoService.getValueByRedisKey("name");
                    logger.debug("key为name的redis数据:"+va);
                }
            }
        
        写好上面的测试代码，选择方法名，右键–>Run as –>JUnit test运行，如下图：  
        ![SouthEast 29][]
        
        运行出现下图效果，说明接口已经正常了：  
        ![SouthEast 30][]  
        另外两个接口的测试效果分别如下：  
        ![SouthEast 31][]
        
        ![SouthEast 32][]  
        ![SouthEast 33][]

### 总结 ###

到这里，一个基于SpringMvc+MyBatis+MySQL+Maven+Redis搭建一个常规的web项目就已经完成了，虽然没有写什么很牛的技术点；但是涵盖的每个技术所需要用到的东西；后续会对MyBatis和redis进行更详细的，便于更好的在项目中运用，提高项目的性能。

[Link 1]: https://git.oschina.net/pengfeilu/springmvc
[SpringMvc_MyBatis_MySQL_Maven_Redis_web]: http://blog.csdn.net/lupengfei1009/article/details/73662432
[jdk1.8]: http://pan.baidu.com/s/1mimgmoS
[SouthEast]: /images/20220613/515a0bfaf47745dca2c63c82b4db49d8.png
[SouthEast 1]: /images/20220613/1747b486fd884650bfe5b7574c24e916.png
[SouthEast 2]: /images/20220613/00ae03ddb9d54c7191e09d2f0f6c26bb.png
[MyEclipse10]: http://pan.baidu.com/s/1jIzb4VG
[maven-3.2.1]: http://pan.baidu.com/s/1slHKgaD
[SouthEast 3]: /images/20220613/af0975d49a314e12b2679cb1791f6d67.png
[SouthEast 4]: /images/20220613/e2a25c2f9c8641c780843dd0b4694280.png
[SouthEast 5]: /images/20220613/c92b8df70ea542d8a16785a6726c1456.png
[SouthEast 6]: /images/20220613/d6c43582763840e8835e21ff91be6850.png
[SouthEast 7]: /images/20220613/923cb4e8f3e04e8d9994b4c655b93453.png
[SouthEast 8]: /images/20220613/d6b3e4900a59463d889fdf289fc29d39.png
[SouthEast 9]: /images/20220613/a5018f38b2644852be71d23b6f6a9fb4.png
[MySQL_Navicat]: http://pan.baidu.com/s/1miwV8e8
[MySQL]: http://blog.csdn.net/lupengfei1009/article/details/52625439
[Tomcat 7.0]: http://pan.baidu.com/s/1pLK5YGV
[SouthEast 10]: /images/20220613/7930b783f8a54071be6af90b5b2cd166.png
[SouthEast 11]: /images/20220613/d045c3356eff464397ccfe9de738bb56.png
[SouthEast 12]: /images/20220613/9e0804708d2a4d3092451478b8a6a5f9.png
[Redis]: http://www.runoob.com/redis/redis-install.html
[Redis-x64-3.2.100]: http://pan.baidu.com/s/1i4XtlHF
[SouthEast 13]: /images/20220613/6a1584e2217941d59fd026c5e308a93e.png
[SouthEast 14]: /images/20220613/55a06378184141138a357151cb467edd.png
[SouthEast 15]: /images/20220613/ef933fa4ee3a430ab2ee8c9ca7ec6d3e.png
[SouthEast 16]: /images/20220613/b04a86c9a5854bd3b3e1bb6a7136c315.png
[SouthEast 17]: /images/20220613/8b5f0b2d10ae4f3ab4ba89f9c02c8056.png
[SouthEast 18]: /images/20220613/c1146bc841fb4d6d8d2f4fb1a7b4c6e0.png
[SouthEast 19]: /images/20220613/cf87bc54d78f4cdfba8f26b3b0ed1c88.png
[SouthEast 20]: /images/20220613/761559f878084b169c3678a873e5f0fa.png
[SouthEast 21]: /images/20220613/a6c99681eaf845c29c2b82d8221e5643.png
[Link 2]: http://pan.baidu.com/s/1miaBt7i
[JedisUtil]: http://pan.baidu.com/s/1dF1nRYL
[SouthEast 22]: /images/20220613/cdda511d20e9441bb6dc269adadd3963.png
[SouthEast 23]: /images/20220613/4bff796d7a754ec7b2a6b329a43acc05.png
[SouthEast 24]: /images/20220613/2bead9ca828246808e002b5966be01da.png
[http_localhost_8080_SpringMvc]: http://localhost:8080/SpringMvc
[SouthEast 25]: /images/20220613/366098595768407a93797e684cf26dbc.png
[http_localhost_8080_SpringMvc_userInfo]: http://localhost:8080/SpringMvc/userInfo
[http_localhost_8080_SpringMvc_userInfo_id_1]: http://localhost:8080/SpringMvc/userInfo?id=1
[SouthEast 26]: /images/20220613/14d62825193341c786c022e6389cfb2d.png
[SouthEast 27]: /images/20220613/a6ce96d21af14823ad16d47a31feead5.png
[http_localhost_8080_SpringMvc_getUserInfos]: http://localhost:8080/SpringMvc/getUserInfos
[SouthEast 28]: /images/20220613/02055373297d4f9ea47bac5a625db499.png
[SouthEast 29]: /images/20220613/d4a3d280ca9945a390a821a7a42e7b91.png
[SouthEast 30]: /images/20220613/d694efd8354c4d18bfccab7ac89b760b.png
[SouthEast 31]: /images/20220613/ca4c2dff92d044f7818570a769f7bda1.png
[SouthEast 32]: /images/20220613/b79e603bc7b748f290f1c7eaf9901fed.png
[SouthEast 33]: /images/20220613/57584c6d76da4bf18fcc43e805350823.png