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

要求 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.csdn.net/download/qq_41193701/10867091
点击下载源码

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

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

猜你喜欢

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