Eclipse 搭建 Maven Spring Mvc+MyBatis Web 项目 清晰教程

1. 要求 Eclipse Maven 环境配置完善
   打开eclipce 点击左上角 file-new file-other-Maven-Maven Project

选择Maven-Maven-Project 创建maven项目 最后选择Next
这里我选择是第二个选项“也就是选择你所保存项目的路径 点击Browse”

选择路径过后 点击maven-archetype-webapp 有的朋友eclipse 中安装了javaee6Web 插件 也可以选择 webapp-javaee6选项 最后点击Next

Group Id 为项目结构 我这里直接为com，Artifact Id 为你要创建的项目名称，version 为war包的版本 Package为部署完的包名 当然也可以和Group Id名一致 最后点击finish

**项目创建成功 开始上面的教程我创建的MavenSpringMvcDemo1 是因为我在写入博客是已经将此项目测试通过了 **

创建各个包层次的结构 我的如下

src/main/resources 文件是单独创建的一个资源文件 里面放各个spring-mvc的配置文件 创建方式点击src/main/main右键Source folder 这里 需要选择Browrse 选择本项目名（创建在当前项目文件结构下面）最后输入你想要的名字
接下来重要的部分来了 首先配置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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com</groupId>
    <artifactId>MavenSpringMvcDemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>MavenSpringMvcDemo</name>

    <properties>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>6.0</version>
            <scope>provided</scope>
        </dependency>
          	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-jdbc</artifactId>
	    <version>4.3.5.RELEASE</version>
  	</dependency>
  	 		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-webmvc</artifactId>
	    <version>4.3.5.RELEASE</version>
	</dependency>
 	<!--上传文件相关的jar包  -->
 	<dependency>
	    <groupId>commons-io</groupId>
	    <artifactId>commons-io</artifactId>
	    <version>2.4</version>
  	</dependency>
  	
  	<dependency>
	    <groupId>commons-fileupload</groupId>
	    <artifactId>commons-fileupload</artifactId>
	    <version>1.3.1</version>
  	</dependency>
  	
  	<dependency>
	    <groupId>org.apache.commons</groupId>
	    <artifactId>commons-lang3</artifactId>
	    <version>3.3.2</version>
  	</dependency>		
	<!-- jstl -->
	<dependency>
	    <groupId>jstl</groupId>
	    <artifactId>jstl</artifactId>
	    <version>1.2</version>
	</dependency>
  	<!--跟加密算法相关的codeC  -->
	<dependency>
	    <groupId>commons-codec</groupId>
	    <artifactId>commons-codec</artifactId>
	    <version>1.9</version>
	</dependency>
 	
 	<!--orm或者jdbc组件需要用到的jar包 mybatis  -->
	<!--mysql数据库驱动  -->
	<dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>5.0.8</version>
	    <scope>runtime</scope>
	</dependency>	
	<!--阿里的连接  druid连接池 类似于c3p0  -->
 	<dependency>
	    <groupId>com.alibaba</groupId>
	    <artifactId>druid</artifactId>
	    <version>1.0.15</version>
	</dependency>
 	
 	 <dependency>
	    <groupId>org.mybatis</groupId>
	    <artifactId>mybatis</artifactId>
	    <version>3.3.1</version>
	</dependency> 
	<dependency>
	    <groupId>org.mybatis</groupId>
	    <artifactId>mybatis-spring</artifactId>
	    <version>1.2.4</version>
	</dependency>
	
	<dependency>
	    <groupId>com.github.pagehelper</groupId>
	    <artifactId>pagehelper</artifactId>
	    <version>4.2.1</version>
	</dependency>
	<!-- lg4j -->
	<!-- https://mvnrepository.com/artifact/log4j/log4j -->
	<dependency>
	    <groupId>log4j</groupId>
	    <artifactId>log4j</artifactId>
	    <version>1.2.17</version>
	</dependency>
	<!-- org.apache.commons -->
	<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
	<dependency>
	    <groupId>org.apache.commons</groupId>
	    <artifactId>commons-lang3</artifactId>
	    <version>3.4</version>
	</dependency>
	<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
	<dependency>
	    <groupId>commons-beanutils</groupId>
	    <artifactId>commons-beanutils</artifactId>
	    <version>1.9.1</version>
	</dependency>
		<!-- org.slf4j -->
	<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
	<dependency>
	    <groupId>org.slf4j</groupId>
	    <artifactId>slf4j-api</artifactId>
	    <version>1.7.25</version>
	</dependency>
	<!-- aspectjweaver -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.11</version>
		</dependency>
		<!-- aspectjrt -->
		<dependency>
			<groupId>aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.5.3</version>
		</dependency>
	   <!-- jackson依赖包 -->
	    <dependency>
	        <groupId>com.fasterxml.jackson.core</groupId>
	        <artifactId>jackson-core</artifactId>
	        <version>2.9.5</version>
	    </dependency>
	    <dependency>
	        <groupId>com.fasterxml.jackson.core</groupId>
	        <artifactId>jackson-databind</artifactId>
	        <version>2.9.5</version>
	    </dependency>
	  	<dependency>
		    <groupId>com.fasterxml.jackson.core</groupId>
		    <artifactId>jackson-annotations</artifactId>
		    <version>2.9.5</version>
	  	</dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <compilerArguments>
                        <endorseddirs>${endorsed.dir}</endorseddirs>
                    </compilerArguments>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.1.1</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.1</version>
                <executions>
                    <execution>
                        <phase>validate</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${endorsed.dir}</outputDirectory>
                            <silent>true</silent>
                            <artifactItems>
                                <artifactItem>
                                    <groupId>javax</groupId>
                                    <artifactId>javaee-endorsed-api</artifactId>
                                    <version>6.0</version>
                                    <type>jar</type>
                                </artifactItem>
                            </artifactItems>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

dbconfig.properties文件（链接数据库池 注意username和password需要跟自己的sql链接池一致）

jdbc.mysql.driver=com.mysql.jdbc.Driver
jdbc.mysql.url=jdbc:mysql://127.0.0.1:3306/test_db?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
jdbc.mysql.username=root
jdbc.mysql.password=123456
#connection pool settings
druid.initialSize=1
druid.maxActive=20
#druid.maxIdle=10
druid.minIdle=5
druid.maxWait=60000
druid.removeAbandoned=true
druid.removeAbandonedTimeout=1200
druid.timeBetweenEvictionRunsMillis=60000
druid.minEvictableIdleTimeMillis=300000
druid.validationQuery= SELECT 1 FROM DUAL
druid.testWhileIdle=true
druid.testOnBorrow=false
druid.testOnReturn=false
druid.poolPreparedStatements=true
druid.maxPoolPreparedStatementPerConnectionSize=50
druid.filters=stat

spring-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:aop="http://www.springframework.org/schema/aop" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/aop 
						http://www.springframework.org/schema/aop/spring-aop.xsd
						http://www.springframework.org/schema/context 
						http://www.springframework.org/schema/context/spring-context.xsd
						http://www.springframework.org/schema/tx 
						http://www.springframework.org/schema/tx/spring-tx.xsd">

    <description>Spring Configuration</description>
    
    <!-- 启用注解 -->
	<context:annotation-config />
	
	<!-- 启动组件扫描，排除@Controller组件，该组件由SpringMVC配置文件扫描 -->
	<context:component-scan base-package="com">
		<context:exclude-filter type="annotation"
			expression="org.springframework.stereotype.Controller" />
	</context:component-scan>
   
	<import resource="spring-datasource.xml"/>
</beans>

**spring-datasource.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"
       default-lazy-init="true">

    <!-- 数据源配置, 使用应用服务器的数据库连接池 -->
    <!--<jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/${jndi.name}" />-->
	<!-- 读取数据库配置文件 -->
	<context:property-placeholder ignore-unresolvable="true" location="classpath*:/spring/dbconfig.properties" /> 

	<!-- 配置数据源 -->
	<bean name="mysqlDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.mysql.driver}"/>
		<property name="url" value="${jdbc.mysql.url}" />
		<property name="username" value="${jdbc.mysql.username}" />
		<property name="password" value="${jdbc.mysql.password}" />
		<!-- 初始化连接数量 -->
        <property name="initialSize" value="${druid.initialSize}" />
        <!-- 最大并发连接数 -->
        <property name="maxActive" value="${druid.maxActive}" />
        <!-- 最大空闲连接数 -->
      <!--   <property name="maxIdle" value="${druid.maxIdle}" /> -->
        <!-- 最小空闲连接数 -->
        <property name="minIdle" value="${druid.minIdle}" />
        <!-- 配置获取连接等待超时的时间 -->     
        <property name="maxWait" value="${druid.maxWait}" />
        <!-- 超过时间限制是否回收 -->
        <property name="removeAbandoned" value="${druid.removeAbandoned}" />
        <!-- 超过时间限制多长； -->
        <property name="removeAbandonedTimeout" value="${druid.removeAbandonedTimeout}" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="${druid.timeBetweenEvictionRunsMillis}" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="${druid.minEvictableIdleTimeMillis}" />
        <!-- 用来检测连接是否有效的sql，要求是一个查询语句-->
        <property name="validationQuery" value="${druid.validationQuery}" />
        <!-- 申请连接的时候检测 -->
        <property name="testWhileIdle" value="${druid.testWhileIdle}" />
        <!-- 申请连接时执行validationQuery检测连接是否有效，配置为true会降低性能 -->
        <property name="testOnBorrow" value="${druid.testOnBorrow}" />
        <!-- 归还连接时执行validationQuery检测连接是否有效，配置为true会降低性能  -->
        <property name="testOnReturn" value="${druid.testOnReturn}" />
        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
        <property name="poolPreparedStatements" value="${druid.poolPreparedStatements}" />     
        <property name="maxPoolPreparedStatementPerConnectionSize" value="${druid.maxPoolPreparedStatementPerConnectionSize}" />
        <!--属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：                 
                监控统计用的filter:stat
                日志用的filter:log4j
               防御SQL注入的filter:wall -->
        <property name="filters" value="${druid.filters}" />     
	</bean>

    <!-- MyBatis配置 -->
    <bean id="mysqlSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="mysqlDataSource" />
        <!-- 自动扫描entity目录, 省掉xml里的手工配置 -->
        <property name="typeAliasesPackage" value="com.entity" />
        <!-- 显式指定Mapper文件位置  -->
        <property name="mapperLocations">
            <list>
                <value>classpath:/mybatis/*Mapper.xml</value>             
    <!--             <value>classpath:/mybatis/UiPages/*Mapper.xml</value> -->
            </list>
        </property>
        <property name="plugins"><array><ref bean="pagePlugin" /></array></property>
    </bean>
    <!-- 分页配置-->
    <bean id="pagePlugin" class="com.common.mybatis.PageInterceptor">
		<property name="properties">
			<props>
				<prop key="databaseType">mysql</prop>
			</props>
		</property>
	</bean>
    <!-- 分页配置end-->
    <!-- 扫描basePackage下所有以@MyBatisRepository标识的 接口-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="mysqlSqlSessionFactory"/>
        <property name="basePackage" value="com.repository" />
        <!-- 优化速度-->
        <property name="annotationClass" value="com.repository.base.AllBatis"/>
    </bean>
	<!-- 配置事务管理器 -->
	<bean id="mysqlTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="mysqlDataSource" />
	</bean>
	<!--  拦截器方式配置事务 -->
	<tx:advice id="mysqlTransactionAdvice" transaction-manager="mysqlTransactionManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="find*" propagation="SUPPORTS" />
			<tx:method name="*" propagation="SUPPORTS" />
		</tx:attributes>
	</tx:advice>
	<aop:config proxy-target-class="true">
		<aop:pointcut id="mysqlTransactionPointcut" expression="execution(* com.service.*.*(..))" />
		<aop:advisor pointcut-ref="mysqlTransactionPointcut" advice-ref="mysqlTransactionAdvice" />
	</aop:config>
	<tx:annotation-driven transaction-manager="mysqlTransactionManager" proxy-target-class="true" />
</beans>

spring-mvc.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

  	<!-- 启动注解驱动的Spring MVC功能，注册请求url和注解POJO类方法的映射-->   
    <!--  <mvc:annotation-driven/>	 -->
	<mvc:default-servlet-handler/>
	<!-- 启动对@AspectJ注解的支持 -->  
	<aop:aspectj-autoproxy/> 
	<!-- 通知spring使用cglib而不是jdk的来生成代理方法 AOP可以拦截到Controller -->  
	<aop:aspectj-autoproxy proxy-target-class="true"/>
	
<!-- 	<mvc:interceptors>  
	    使用bean定义一个Interceptor，直接定义在mvc:interceptors根下面的Interceptor将拦截所有的请求  
	    <bean class="com.bybo.aca.web.interceptor.Login"/>   
	    <mvc:interceptor>  
	        进行拦截：/**表示拦截所有controller
	        <mvc:mapping path="/UserController" />
	        <mvc:exclude-mapping path=""/>      
	        <bean class="com.interceptor.LoginInterceptor"/>  
	    </mvc:interceptor>  
   </mvc:interceptors> -->
   
  	<!-- 自动扫描且只扫描@Controller -->
    <context:component-scan base-package="com" use-default-filters="false">
        <!-- 平台的controller，可以写多个 -->
        <context:include-filter type="aspectj" expression="com.controller..*Controller"/>
    </context:component-scan>
    
    <!-- 对静态资源文件的访问  restful-->     
	<mvc:resources mapping="/static/**" location="/,/static/" />
	<mvc:resources mapping="/upload/**" location="/,/upload/" />
	<!--<mvc:resources mapping="/plugins/**" location="/,/plugins/" />
	<mvc:resources mapping="/uploadFiles/**" location="/,/uploadFiles/" />  -->
    
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver" >
		<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>

	<mvc:annotation-driven>
		<mvc:message-converters register-defaults="true">
			<!-- 避免IE执行AJAX时,返回JSON出现下载文件 -->
			<bean
				class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
				<property name="supportedMediaTypes">
					<list>
						<value>text/html;charset=UTF-8</value>
						<value>text/json;charset=UTF-8</value>
						<value>application/json;charset=UTF-8</value>
					</list>
				</property>
			</bean>
		</mvc:message-converters>
	</mvc:annotation-driven>
	<!-- 配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包 -->
	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<!-- 默认编码 -->
		<property name="defaultEncoding" value="utf-8" />
		<!-- 文件大小最大值 -->
		<property name="maxUploadSize" value="1048576000" />
		<!-- 内存中的最大值 -->
		<property name="maxInMemorySize" value="40960" />
	</bean>
</beans>

spring-quartz-task.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-3.0.xsd">
<!-- 用于配置定时任务 可以相应的配置：定义任务、调度、处理时间 -->  
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" />
 
</beans>

spring-shiro.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-4.0.xsd"
       default-lazy-init="true">

    <description>Shiro Configuration</description>

   		 <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
			<property name="realm" ref="ShiroRealm" />
			<!-- <property name="sessionManager" ref="sessionManager"/> -->
					<!-- 使用下面配置的缓存管理器 -->
			<!-- <property name="cacheManager" ref="cacheManager" /> -->
		</bean>
		
		<!-- 項目自定义的Realm -->
	    <bean id="ShiroRealm" class="com.interceptor.shiro.ShiroRealm" ></bean>
		
		<!-- Shiro Filter -->
		<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
			<property name="securityManager" ref="securityManager" />		
			<property name="loginUrl" value="/loginIndex" />		
			<property name="successUrl" value="/backstage/index" />	
			<property name="unauthorizedUrl" value="/loginIndex" />
				<!-- anon:匿名拦截器，即不需要登录即可访问；一般用于静态资源过滤
            		 authc:如果没有登录会跳到相应的登录页面登录
            		 user:用户拦截器，用户已经身份验证/记住我登录的都可 -->
			<property name="filterChainDefinitions">
			<value>
	           	/static/js/system/login/**  = anon
	           	/static/js/system/**		= authc
				/static/** 				    = anon
				</value>
			</property>
		</bean>
	   <!-- 缓存管理器 使用Ehcache实现-->  
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">  
        <property name="cacheManagerConfigFile" value="classpath:/spring/ehcache.xml"/>  
    </bean>  
       
      <!-- AOP式方法级权限检查 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor">
        <property name="proxyTargetClass" value="true" />
    </bean>
    
    <!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
</beans>

log4j.properties

log4j.rootLogger=DEBUG,CONSOLE,Log,LogSize
log4j.addivity.org.apache=false

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Threshold=DEBUG
log4j.appender.CONSOLE.ImmediateFlush = TRUE 
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd HH\:mm\:ss} -%-4r [%t] %-5p  %x - %m%n
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.encoding=UTF-8

**将这些资源文件放入此文件spring下面 mybatis文件存放数据库相关的Mapper
文件后面需要用到 **

数据库的创建 并加入测试数据

 DROP DATABASE IF EXISTS test_db;
 CREATE DATABASE test_db;
 USE test_db;
 
DROP TABLE IF EXISTS tinfo;

CREATE TABLE tinfo
(
    infoId  INT PRIMARY KEY AUTO_INCREMENT,
    uname   VARCHAR(50) DEFAULT NULL,
    sex     VARCHAR(20) DEFAULT NULL,
    age     VARCHAR(20) DEFAULT NULL
)
SELECT * FROM tinfo;
INSERT INTO tinfo (uname,sex,age)VALUES('张三','男','20');
INSERT INTO tinfo (uname,sex,age)VALUES('张三','男','20');
INSERT INTO tinfo (uname,sex,age)VALUES('张三','男','20');
INSERT INTO tinfo (uname,sex,age)VALUES('张三','男','20');
DELETE FROM tinfo WHERE infoId=1;

实体层 创建实体类基础表（可以不用创建因为习惯在mapper中实体链接id使用别名所以此处我创建了）

package com.entity.base;

import java.io.Serializable;
/**
 * 实体类基础表
 */
public class BaseEntity implements Serializable {
	
	private static final long serialVersionUID = 1L;
	
}

数据库相关实体 使用注解@Alias(“BaseTinfoEntity”) 便于mapper中使用

package com.entity;

import org.apache.ibatis.type.Alias;

import com.entity.base.BaseEntity;
@Alias("BaseTinfoEntity")
public class TinfoEntity extends BaseEntity{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private Integer infoId;//  INT PRIMARY KEY AUTO_INCREMENT,
    private String uname;//   VARCHAR(50) DEFAULT NULL,
    private String sex;//     VARCHAR(20) DEFAULT NULL,
    private String age ;//    VARCHAR(20) DEFAULT NULL
	public TinfoEntity() {
		super();
		// TODO Auto-generated constructor stub
	}
	public TinfoEntity(Integer infoId, String uname, String sex, String age) {
		super();
		this.infoId = infoId;
		this.uname = uname;
		this.sex = sex;
		this.age = age;
	}
	@Override
	public String toString() {
		return "TinfoEntity [infoId=" + infoId + ", uname=" + uname + ", sex=" + sex + ", age=" + age + "]";
	}
	public Integer getInfoId() {
		return infoId;
	}
	public void setInfoId(Integer infoId) {
		this.infoId = infoId;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
    
}

dao层 放入repository文件下 创建 AllBatis 标识MyBatis的DAO,方便{@link org.mybatis.spring.mapper.MapperScannerConfigurer}的扫描。

package com.repository.base;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.stereotype.Component;

/**
 * 标识MyBatis的DAO,方便{@link org.mybatis.spring.mapper.MapperScannerConfigurer}的扫描。
 * 
 * 
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)//标注指向类、接口
@Documented
@Component
public @interface AllBatis {
	String value() default "";
}

基础通用BaseDao interface 类型 只需直接调用接口即可

package com.repository.base;

import java.util.List;

import org.apache.ibatis.annotations.Param;


public interface BaseDao<T> {
	/**
	 * 保存一个对象
	 * @param o 对象
	 * @return 对象的ID
	 */
	public void insert(T o);
	/**
	 * 删除一个对象
	 * @param o  对象
	 */
	public void delete(T o);
	/**
	 * 更新一个对象
	 * @param o 对象       
	 */
	public void update(T o);
	/**
	 * 批量删除一组对象
	 * @param s (主键)数组
	 */
	public void deleteBatch(List<T> os);
	/**
	 * 获得对象列表
	 * @param o 对象       
	 * @return List
	 */
	public List<T> find(T o);	
	/**
	 * 获得对象列表
	 * @param o 对象       
	 * @param page 分页对象
	 * @return List
	 */
	public int count(T o);
}

实体TinfoDao层（注解@AllBatis 不能缺少）

package com.repository;

import com.entity.TinfoEntity;
import com.repository.base.AllBatis;
import com.repository.base.BaseDao;
@AllBatis
public interface TinfoDao extends BaseDao<TinfoEntity>{

}

创建BaseService层 接口类型 方便后面调用

package com.service.base;

import java.util.List;

import com.common.mybatis.Page;

public interface BaseService<T> {
	/**
	 * 保存一个对象
	 * @param o 对象
	 * @return 对象的ID
	 */
	public void insert(T o);	
	/**
	 * 删除一个对象
	 * @param o  对象
	 */
	public void delete(T o);
	/**
	 * 批量删除一个对象
	 * @param s (主键)数组
	 */
	public void deleteBatch(List<T> os);
	/**
	 * 更新一个对象
	 * @param o 对象       
	 */
	public void update(T o);
	/**
	 * 获得对象列表
	 * @param o 对象       
	 * @return List
	 */
	public List<T> find(T o);	
	/**
	 * 统计数目
	 * @param o 对象      
	 * @return long
	 */
	public int count(T o);
}

BaseServiceImp实现类

package com.service.base;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import com.repository.base.BaseDao;


public class BaseServiceImp<T> implements BaseService<T>{

	protected Logger logger = LoggerFactory.getLogger(this.getClass());
	
	@Autowired
	protected BaseDao<T> baseDao;

	@Override
	public void insert(T o) {
		baseDao.insert(o);
	}

	@Override
	public void delete(T o) {
		baseDao.delete(o);
	}
	
	@Override
	public void deleteBatch(List<T> os){
		baseDao.deleteBatch(os);
	}

	@Override
	public void update(T o) {
		baseDao.update(o);
	}

	@Override
	public List<T> find(T o) {
		return baseDao.find(o);
	}

	@Override
	public int count(T o) {
		return baseDao.count(o);
	}
}

TinfoService 继承前者BaseService

package com.service;

import com.entity.TinfoEntity;
import com.service.base.BaseService;

public interface TinfoService extends BaseService<TinfoEntity>{

}

TinfoServiceImp实现类 继承BaseServiceImp并调用BaseServiceImp接口（这不需要在写相关sql语句方法）

package com.service;

import org.springframework.stereotype.Service;

import com.entity.TinfoEntity;
import com.service.base.BaseServiceImp;
@Service("TinfoService")
public class TinfoServiceImp extends BaseServiceImp<TinfoEntity> implements TinfoService{

}

BaseController层

package com.controller.base;


import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.ModelAndView;



public class BaseController<T> {
	
	protected Logger logger = LoggerFactory.getLogger(this.getClass());

	/**
	 * 得到ModelAndView
	 */
	public ModelAndView getModelAndView(){
		return new ModelAndView();
	}
	
	/**
	 * 得到request对象
	 */
	public HttpServletRequest getRequest() {
		HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();	
		return request;
	}
	public static void logBefore(Logger logger, String interfaceName){
		logger.info("");
		logger.info("start");
		logger.info(interfaceName);
	}
	
	public static void logAfter(Logger logger){
		logger.info("end");
		logger.info("");
	}
}

实现的PageController层

package com.controller;

import java.util.List;

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 com.entity.TinfoEntity;
import com.service.TinfoService;

@Controller
public class PageController {
	@Autowired
	private TinfoService tinfoService;
	
	
	@RequestMapping("/welcome")
	public String shouye(TinfoEntity tinfo,Model md){
		List<TinfoEntity> infos=tinfoService.find(tinfo);
		System.out.println("======================================="+infos);
		return "holle";
	}
}

结构图 图中（common和interceptor在我们当前项目中用到所有没有给大家展示代码片段）

接下来就是Mapper相关的配置

<?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.repository.TinfoDao">

    <resultMap id="base" type="BaseTinfoEntity"></resultMap>  
    <!-- 查询信息-->
	 <select id="find" parameterType="BaseTinfoEntity" resultMap="base">
        SELECT * FROM  tinfo
    </select>
    <delete id="delete" parameterType="BaseTinfoEntity">
        DELETE FROM tinfo WHERE infoId=#{infoId};
    </delete>
    <!-- 添加用户 -->
    <insert id="insert"  parameterType="BaseTinfoEntity">	
  	<![CDATA[
	   INSERT INTO tinfo (uname,sex,age)VALUES(#{uname},#{sex},#{age});
 	]]>  
	</insert>
	<!-- 更改信息 -->
	<update id="update" parameterType="BaseTinfoEntity">
	  UPDATE tinfo SET age=#{age}
      WHERE infoId=#{infoId};
	</update>
</mapper>

基本配置到此就结束了 接下来就测试（现在控制台输出看是否成功 我这里给大家先测试查询数据）当然的在服务器也配置好了的情况下 才可运行tomcat（配置服务器我就不详说了 大家应该都会）点击Run on Service 等待服务器的发布

控制台数据查询成功

接下来就是部署web-inf中的jsp页面 很多朋友在这里可能找不到这个文件 那么直接创建一个就可以了 创建在webapp文件下

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>SpringMVC</display-name>
  <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/spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.properties</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
  </listener>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:/spring/spring-application.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <listener>
    <listener-class>com.common.utils.SpringWebContextUtil</listener-class>
  </listener>
  <filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
  </filter-mapping>
  <error-page>
    <error-code>404</error-code>
    <location>/404.jsp</location>
  </error-page>
  <error-page>
    <error-code>500</error-code>
    <location>/500.jsp</location>
  </error-page>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  <session-config>
    <session-timeout>600</session-timeout>
  </session-config>
</web-app>

index.jsp(此处path+“” 为默认就会访问的页面 /welcome为控制中的路径)

<%@ page language="java" pageEncoding="UTF-8"%>  
<%  
	String path = request.getContextPath();  
	String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
	response.sendRedirect(path+"/welcome");
%>  

接下来在控制器中添加md.addAttribute(“infos”,infos); 目的是给下面的jsp页面传输值

	@RequestMapping("/welcome")
	public String shouye(TinfoEntity tinfo,Model md){
		List<TinfoEntity> infos=tinfoService.find(tinfo);
		System.out.println("======================================="+infos);
		md.addAttribute("infos",infos);
		return "holle";
	}

holle.jsp 此处我使用的是jstl中的c:forEach的表单式来显示数据

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>欢迎您</title>
</head>
<body>
<p>欢迎您</p>

										   <table>
										        <thead>
													<tr>
													      <td>姓名</td>
													      <td>性别</td>
													      <td>年龄</td>
													</tr>										
													   <c:forEach items="${infos}" var="infos">
													      <tr>					
													      <td>${infos.uname}</td>
													      <td>${infos.sex}</td>
													      <td>${infos.age}</td>													      
													      <td onclick="up('${infos.infoId}')" id="${infos.infoId}">修改</td>
													      <td onclick="dinfo('${infos.infoId}')" id="${infos.infoId}">删除</td>
													   </tr>
													   </c:forEach>
												</thead>
											</table>
											<form action="post" id="form">
											<input id="uname" name="uname">
											<input id="sex" name="sex">
											<input id="age" name="age">
											<input type="button" value="添加" id="add">
											</form>	
																		
											<form action="post" id="upform">											
											<input id="infoId" name="infoId">
											<input id="age" name="age">
											<input type="button" value="修改" id="upi">
											</form>
</body>
<script src="https://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js"></script>
<script type="text/javascript">
function dinfo(infoId){
	 location.href="del?infoId="+infoId;
		//重新刷新页面
		window.location.reload();
	}
//修改
function up(infoId){
	 $("#infoId").val(infoId);
	  $("#upi").click(function(){		  
			var dataJson="{";
			var dataArr=[];
			$("#upform").find("input").each(function(index,_this){
				var inputN=$(_this).attr("name");
				if(inputN!="" && inputN!=null){
					dataArr.push(inputN+":'"+$(_this).val()+"'");
					dataJson+=",";
				}
			});
			dataJson="{"+dataArr.join(",")+"}";
			console.log(dataJson);		
			var jsonForms=eval('('+dataJson+')');
			console.log(dataJson);
	    $.post("upinfo",jsonForms,function(data){
				console.log(data);
				var json=$.parseJSON(data);
				alert(json.resMsg);
				//重新刷新页面
				window.location.reload();
			});
	  }); 
	}
	//添加
	  $(function(){
		  $("#add").click(function(){		  
				var dataJson="{";
				var dataArr=[];
				$("#form").find("input").each(function(index,_this){
					var inputN=$(_this).attr("name");
					if(inputN!="" && inputN!=null){
						dataArr.push(inputN+":'"+$(_this).val()+"'");
						dataJson+=",";
					}
				});
				dataJson="{"+dataArr.join(",")+"}";
				console.log(dataJson);		
				var jsonForms=eval('('+dataJson+')');
				console.log(dataJson);
		    $.post("int",jsonForms,function(data){
					console.log(data);
					var json=$.parseJSON(data);
					alert(json.resMsg);
					//重新刷新页面
					window.location.reload();
				});
		  }); 
	  });
</script>
</html>

最终效果 当服务器启动过后再浏览器中输入地址链接http://localhost:8080/MavenSpringMvcDemo

数据查询成功 对于后面的添加 删除 和修改数据 大家可以在可控制器中直接调相关方法就可以了
源码链接地址https://download.youkuaiyun.com/download/qq_41193701/10867091
点击下载源码

以前问题很多都是在优快云上面找到解决方案 觉得资源和解答方案的共享是非常好的一件事 现在第一次使用优快云 还请大家多多关照 欢迎大家浏览意见 还有其他关于本次代码不懂的地方可以留言给我 我会尽快给大家解答
注： 以上关于搭建Maven spring mvc+mybatis的代码只供教学使用