Spring+SpringMVC+Mybatis+Maven

最新推荐文章于 2022-06-27 17:55:38 发布
最新推荐文章于 2022-06-27 17:55:38 发布
阅读量274 收藏
点赞数
分类专栏： Spring、SpringMVC、Maven、MYSQL 文章标签： Maven Spring SpringMVC MYSQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36348637/article/details/78990564
版权

Maven整合spring整合springMVC整合Mybatis

工具：eclipse javaee IDE

1.先附上maven项目结构图

2.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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.zhao</groupId>
  <artifactId>ssm</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>ssm Maven Webapp</name>
  <url>http://maven.apache.org</url>
	  
  <properties>
  	<!-- spring版本号 -->  
    <spring.version>4.3.9.RELEASE</spring.version>
	<!-- 数据库driver版本号 -->
	<mysql.version>5.1.30</mysql.version>
	<!-- mybatis版本号 -->  
    <mybatis.version>3.2.6</mybatis.version>
    <spring.mybatis.version>1.2.3</spring.mybatis.version>
    <!-- log4j日志文件管理包版本 -->  
    <log4j.version>1.2.17</log4j.version>
        
  </properties>
  
  <dependencies>
  	<!-- 表示开发的时候引入，发布的时候不会加载此包 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <!-- 导入Mysql数据库链接driver jar包 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>${mysql.version}</version>
	</dependency>
	<!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->  
    <dependency>  
        <groupId>commons-dbcp</groupId>  
        <artifactId>commons-dbcp</artifactId>  
        <version>1.2.2</version>  
    </dependency>
    <!-- mybatis -->  
    <dependency>  
        <groupId>org.mybatis</groupId>  
        <artifactId>mybatis</artifactId>  
        <version>${mybatis.version}</version>  
    </dependency>  
    <dependency>  
        <groupId>org.mybatis</groupId>  
        <artifactId>mybatis-spring</artifactId>  
        <version>${spring.mybatis.version}</version>  
    </dependency>
    <!-- 日志核心包 -->
    <dependency>  
        <groupId>log4j</groupId>  
        <artifactId>log4j</artifactId>  
        <version>${log4j.version}</version>  
    </dependency>
    <!-- <dependency>
		<groupId>log4j-api</groupId>
		<artifactId>log4j-api</artifactId>
		<version>2.2</version>
	</dependency>
	<dependency>
		<groupId>log4j-core</groupId>
		<artifactId>log4j-core</artifactId>
		<version>2.2</version>
	</dependency> -->
	<dependency>
		<groupId>commons-logging</groupId>
		<artifactId>commons-logging</artifactId>
		<version>1.1.3</version>
	</dependency>
    
    
    <!-- javaEE -->
    <dependency>
		<groupId>javax.servlet</groupId>
		<artifactId>servlet-api</artifactId>
		<version>2.5</version>
		<scope>provided</scope>
	</dependency>
	<dependency>
		<groupId>javax.servlet.jsp</groupId>
		<artifactId>jsp-api</artifactId>
		<version>2.1</version>
		<scope>provided</scope>
	</dependency>
	<dependency>
		<groupId>javax.servlet</groupId>
		<artifactId>jstl</artifactId>
		<version>1.2</version>
	</dependency>
	<!-- spring核心包 -->  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-core</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-beans</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-expression</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-web</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-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-instrument</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-instrument-tomcat</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-jms</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-oxm</artifactId>  
        <version>${spring.version}</version>  
    </dependency>
    <dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-webmvc-portlet</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.perf4j</groupId>
		<artifactId>perf4j</artifactId>
		<version>0.9.16</version>
	</dependency>  
  	<dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-orm</artifactId>  
        <version>${spring.version}</version>  
    </dependency>
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-aspects</artifactId>  
        <version>${spring.version}</version>  
    </dependency>
    <dependency>  
        <groupId>org.aspectj</groupId>  
        <artifactId>aspectjrt</artifactId>  
        <version>1.6.11</version><!--  -->  
    </dependency>  
    <dependency>  
        <groupId>org.aspectj</groupId>  
        <artifactId>aspectjweaver</artifactId>  
        <version>1.8.9</version>  
    </dependency>  
    <dependency>  
        <groupId>cglib</groupId>  
        <artifactId>cglib</artifactId>  
        <version>2.1_3</version>  
    </dependency>
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-test</artifactId>  
        <version>${spring.version}</version>  
    </dependency>
	<!-- JSTL标签类 -->  
    <dependency>  
        <groupId>jstl</groupId>  
        <artifactId>jstl</artifactId>  
        <version>1.2</version>  
    </dependency>
    
    <!-- json工具 -->
	<dependency>  
    	<groupId>com.fasterxml.jackson.core</groupId>  
    	<artifactId>jackson-core</artifactId>  
    	<version>2.5.2</version>  
	</dependency>  
  
	<dependency>  
    	<groupId>com.fasterxml.jackson.core</groupId>  
    	<artifactId>jackson-databind</artifactId>  
    	<version>2.5.2</version>  
	</dependency>
	
	<!-- apache工具 -->
	<dependency>
		<groupId>commons-fileupload</groupId>
		<artifactId>commons-fileupload</artifactId>
		<version>1.3.2</version>
	</dependency>
	<dependency>
		<groupId>org.apache.commons</groupId>
		<artifactId>commons-lang3</artifactId>
		<version>3.5</version>
	</dependency>
	<dependency>
		<groupId>commons-lang</groupId>
		<artifactId>commons-lang</artifactId>
		<version>2.6</version>
	</dependency>
    
	
	
  </dependencies>
  
  <build>
  	<defaultGoal>compile</defaultGoal>
    <finalName>ssm</finalName>
    <plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.1</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
			</configuration>
		</plugin>
	</plugins>
  </build>
</project>
3.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>Archetype Created Web Application</display-name> -->
  	
  	<context-param>
		<param-name>webAppRootKey</param-name>
		<param-value>ssm</param-value>
	</context-param>
  	
  	<context-param>
       <param-name>log4jConfigLocation</param-name>      
       <param-value>/WEB-INF/classes/properties/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>
  	
  	<!--过滤字符集 -->  
    <filter>  
        <filter-name>encoding</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>encoding</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>
    
    <!-- spring配置文件 -->  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>classpath:spring/spring-*.xml</param-value>  
    </context-param>
    
    <!-- Spring监听器 -->  
    <listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>  
    <listener>  
        <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>  
    </listener>
    
    <!-- 配置springmvc servlet -->  
    <servlet>  
        <servlet-name>springMVC</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:spring/spring-mvc.xml</param-value>  
        </init-param>  
        <load-on-startup>0</load-on-startup>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>springMVC</servlet-name>  
        <url-pattern>/</url-pattern>  
    </servlet-mapping> 
    
    <!-- 会话超时时间，单位分钟 -->
	<session-config>
		<session-timeout>20</session-timeout>
	</session-config>
    
    <welcome-file-list>  
        <welcome-file>index.jsp</welcome-file>  
    </welcome-file-list> 
  
</web-app>
4.spring-appalication.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:mvc="http://www.springframework.org/schema/mvc" 
        xmlns:context="http://www.springframework.org/schema/context"  
        xmlns:tx="http://www.springframework.org/schema/tx" 
        xmlns:task="http://www.springframework.org/schema/task"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd    
        http://www.springframework.org/schema/context     
        http://www.springframework.org/schema/context/spring-context-4.3.xsd    
        http://www.springframework.org/schema/tx  
        http://www.springframework.org/schema/tx/spring-tx-4.3.xsd  
        http://www.springframework.org/schema/task   
        http://www.springframework.org/schema/task/spring-task-4.3.xsd       
        http://www.springframework.org/schema/aop   
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"  
        default-lazy-init="false">  
      
      
        <bean  
            class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
            <property name="locations">  
                <list>  
                    <value>classpath:properties//jdbc.properties</value>
				  
                    <!-- <value>classpath:redis.properties</value> -->  
                </list>  
            </property>  
            <!-- 忽略不可解析的 -->  
            <property name="ignoreUnresolvablePlaceholders" value="true" />  
        </bean>  
        
        <!-- @Component and @Resource -->
		<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />
		<!-- 对com包中的所有类进行扫描，以完成Bean创建和自动依赖注入的功能 -->
		<context:component-scan base-package="com.zhao" />
		<!-- 注解注入properties -->
		<context:property-placeholder/>
		<!-- 定时器 -->
		<!-- <task:annotation-driven /> -->
		<!-- mvc -->
		<mvc:annotation-driven />
		<!-- Aspect -->
		<aop:aspectj-autoproxy />

		<!-- 异步线程池 -->
		<bean id="threadPool"
			class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
			<!-- 核心线程数 -->
			<property name="corePoolSize" value="10" />
			<!-- 最大线程数 -->
			<property name="maxPoolSize" value="50" />
			<!-- 队列最大长度 >=mainExecutor.maxSize -->
			<property name="queueCapacity" value="1000" />
			<!-- 线程池维护线程所允许的空闲时间 -->
			<property name="keepAliveSeconds" value="600" />
			<!-- 线程池对拒绝任务(无线程可用)的处理策略 -->
			<property name="rejectedExecutionHandler">
				<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
			</property>
		</bean>
        
          
    </beans>
5.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:tx="http://www.springframework.org/schema/tx"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
            http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
            http://www.springframework.org/schema/context  
            http://www.springframework.org/schema/context/spring-context-4.3.xsd  
        	http://www.springframework.org/schema/tx  
        	http://www.springframework.org/schema/tx/spring-tx-4.3.xsd  
            http://www.springframework.org/schema/mvc   
            http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd     
        	http://www.springframework.org/schema/aop   
         	http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"  
        default-lazy-init="false">  
         
        <!-- springmvc 扫包 -->  
        <context:component-scan base-package="com" use-default-filters="false"> 
        	<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
        	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />
        </context:component-scan> 
        <!-- 注解支持 -->  
        <context:annotation-config /> 
        
        <!--HandlerMapping,HandlerAdapter -->
		<!-- <mvc:annotation-driven /> -->

		<!-- 静态资源解析 包括 ：js、html -->
		<!-- <mvc:resources location="/" mapping="*.html" />
		<mvc:resources location="/html/" mapping="/html/**" />
		<mvc:resources location="/js/" mapping="/js/**" />
		<mvc:resources location="/css/" mapping="/css/**" />
		<mvc:resources location="/img/" mapping="/img/**" /> -->
	
        <!--避免IE执行AJAX时，返回JSON出现下载文件 -->  
        <bean id="mappingJackson2HttpMessageConverter"  
            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>  
        <!-- 采用SpringMVC自带的JSON转换工具，支持@ResponseBody注解 -->  
        <bean  
            class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">  
            <property name="ignoreDefaultModelOnRedirect">
				<value>false</value>
			</property>
            <property name="messageConverters">  
                <list>  
                    <ref bean="mappingJackson2HttpMessageConverter" />    <!-- JSON转换器 -->  
                </list>  
            </property>  
        </bean>  
          
         
        <!-- 配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包 -->  
        <bean id="multipartResolver"  
            class="org.springframework.web.multipart.commons.CommonsMultipartResolver">  
            <!-- 默认编码 -->  
            <property name="defaultEncoding" value="utf-8" />  
            <!-- 文件大小最大值 -->  
            <property name="maxUploadSize" value="10485760000" />  
            <!-- 内存中的最大值 -->  
            <property name="maxInMemorySize" value="40960" />  
        </bean>
        
        <!-- 对模型视图名称的解析，即在模型视图名称添加前后缀 -->  
        <bean  
            class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!-- view是用什么显示，这里是jsp，还可以用velocity之类的 -->  
            <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />  
            <!-- 视图文件的前缀 -->
            <property name="prefix" value="/WEB-INF/"></property> 
            <!-- 视图文件的后缀名 --> 
            <property name="suffix" value=".jsp"></property>
        </bean>
        
        
          
        <!-- <import resource="spring-mvc-shiro.xml" /> -->  
    </beans>
6.spring-mybatis.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:tx="http://www.springframework.org/schema/tx" 
        xmlns:task="http://www.springframework.org/schema/task"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans    
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd     
        http://www.springframework.org/schema/context     
        http://www.springframework.org/schema/context/spring-context-4.3.xsd    
        http://www.springframework.org/schema/tx  
        http://www.springframework.org/schema/tx/spring-tx-4.3.xsd  
        http://www.springframework.org/schema/task   
        http://www.springframework.org/schema/task/spring-task-4.3.xsd       
        http://www.springframework.org/schema/aop   
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"  
        default-lazy-init="false">  
      
      
        <!-- <context:component-scan base-package="com.*.service" />  
      
        <bean  
            class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
            <property name="locations">  
                <list>  
                    <value>classpath:jdbc.properties</value>  
                    <value>classpath:redis.properties</value>  
                </list>  
            </property>  
            忽略不可解析的  
            <property name="ignoreUnresolvablePlaceholders" value="true" />  
        </bean>   -->
        <!-- 配置数据源 -->  
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
            <property name="driverClassName" value="${jdbc.driverClass}" />
			<property name="url" value="${jdbc.url}" />
			<property name="username" value="${jdbc.username}" />
			<property name="password" value="${jdbc.password}" />
			<property name="initialSize" value="${jdbc.initialSize}" />
			<property name="minIdle" value="${jdbc.minIdle}" />
			<property name="maxIdle" value="${jdbc.maxIdle}" />
			<property name="maxActive" value="${jdbc.maxActive}" />
			<property name="maxWait" value="${jdbc.maxWait}" />
			<property name="defaultAutoCommit" value="${jdbc.defaultAutoCommit}" />
			<property name="removeAbandoned" value="${jdbc.removeAbandoned}" />
			<property name="removeAbandonedTimeout" value="${jdbc.removeAbandonedTimeout}" />
			<property name="testWhileIdle" value="${jdbc.testWhileIdle}" />
			<property name="timeBetweenEvictionRunsMillis" value="${jdbc.timeBetweenEvictionRunsMillis}" />
			<property name="numTestsPerEvictionRun" value="${jdbc.numTestsPerEvictionRun}" />
			<property name="minEvictableIdleTimeMillis" value="${jdbc.minEvictableIdleTimeMillis}" />
        </bean>  
        <!-- 配置sqlSessionFactory -->  
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
            <!-- <property name="configLocation" value="classpath:mybatis-config.xml" /> -->  
            <property name="dataSource" ref="dataSource" />  
            <!-- 自动匹配Mapper映射文件 -->  
            <property name="mapperLocations" value="classpath:mapper/*.xml" />  
            <property name="typeAliasesPackage" value="com.zhao.dao" />
        </bean>  
        <!-- 通过扫描的模式，扫描在目录下所有的mapper都继承SqlMapper接口的接口， 这样一个bean就可以了 -->  
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
            <property name="basePackage" value="com.zhao.dao" />
        	<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>  
        </bean> 
        
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
			<constructor-arg index="0" ref="sqlSessionFactory" />
		</bean>
		
		<!--proxy-target-class="true"强制使用cglib代理 如果为false则spring会自动选择 -->  
        <aop:config proxy-target-class="true"></aop:config>
		
		<tx:advice id="txAdvice" transaction-manager="transactionManager">
        	<tx:attributes>
            	<tx:method name="*" read-only="false"/>
        	</tx:attributes>
    	</tx:advice>
		
		<!-- (事务管理)transaction manager,user JtaTransaction for globla tx -->
    	<bean id="transactionManager" 
        	class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        	<property name="dataSource" ref="dataSource"/>
    	</bean>
    
    	<!-- 开启事务注解，使用annotation注解方式配置事务  -->
		<tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager" />
		
		 
      
</beans>
7.jdbc.properties 

#=========================================================
#         MySQL数据库连接基本参数
#=========================================================
#链接驱动
jdbc.driverClass=com.mysql.jdbc.Driver
#链接路径  
jdbc.url=jdbc:mysql://localhost:3306/zhao?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
#用户名
jdbc.username=root
#密码  
jdbc.password=root


#=========================================================
#         MySQL数据库连接可设置参数
#=========================================================
  
#初始化连接大小  
jdbc.initialSize=5 
#连接池最大使用连接数量  
jdbc.maxActive=20
#连接池最大空闲  
jdbc.maxIdle=20
#连接池最小空闲  
jdbc.minIdle=5
#获取连接最大等待时间  
jdbc.maxWait=60000
#  
jdbc.testWhileIdle=true
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒  
jdbc.timeBetweenEvictionRunsMillis=60000
#配置一个连接在池中最小生存的时间，单位是毫秒  
jdbc.minEvictableIdleTimeMillis=25200000
#设定在进行后台对象清理时，每次检查几个链接。默认值是3.
#如果numTestsPerEvictionRun>=0, 则取numTestsPerEvictionRun 和池内的链接数 的较小值 作为每次检测的链接数
#如果numTestsPerEvictionRun<0，则每次检查的链接数是检查时池内链接的总数乘以这个值的负倒数再向上取整的结果。
jdbc.numTestsPerEvictionRun=20
#给出一条简单的sql语句进行验证  
jdbc.validationQuery=SELECT 1
#默认的SQL语句自动提交状态(开启或关闭)设置由连接池本身设置(false由连接池定)，不设置该值setAutoCommit方法不被调用；
jdbc.defaultAutoCommit=false
#是否自动回收超时连接
jdbc.removeAbandoned=true
#设置被遗弃的连接的超时的时间（以秒数为单位），即当一个连接被遗弃的时间超过设置的时间，则它会自动转换成可利用的连接。默认的超时时间是300秒。
jdbc.removeAbandonedTimeout=600
 
#jdbc.minPoolSize=2  
#jdbc.maxPoolSize=20  
#jdbc.checkoutTimeout=3000  
#jdbc.maxStatements=50  
#jdbc.testConnectionOnCheckin=false  
#jdbc.idleConnectionTestPeriod=18000
8.log4j.properties 
### set log levels ###
#log4j.rootLogger = info,stdout,D,E
log4j.rootLogger = INFO,stdout,D,E
### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.encoding=GBK
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [SANTAIELE-APSM2.0 Log -->] %d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n

### 输出到日志文件 ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
#设置R的日志最大限制,10M
#log4j.appender.D.MaxFileSize= 10240KB
# 最多只保存20个备份文件
#log4j.appender.D.MaxBackupIndex=20
log4j.appender.D.encoding=GBK
 ## 调试日志文件名
log4j.appender.D.File = ${ssm}/logs/apsm2_info_log.log 
log4j.appender.D.Append = true
## 输出DEBUG级别以上的日志
log4j.appender.D.Threshold = INFO
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = [SANTAIELE-APSM2.0 INFO Log -->] %d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n

### 保存异常信息到单独文件 ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
#设置R的日志最大限制,10M
#log4j.appender.E.MaxFileSize= 10240KB
# 最多只保存20个备份文件
#log4j.appender.E.MaxBackupIndex=20
log4j.appender.E.encoding=GBK
 ## 异常日志文件名
log4j.appender.E.File = ${ssm}/logs/apsm2_error_log.log
log4j.appender.E.Append = true
## 只输出ERROR级别以上的日志!!!
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = [SANTAIELE-APSM2.0 ERROR Log -->] %d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n


#log4j.logger.org.hibernate=info 
log4j.logger.org.hibernate=ERROR   

###   log   HQL   query   parser   activity 
###输出HQL查询调试日志
#log4j.logger.org.hibernate.hql.ast.AST=debug 

###   log   just   the   SQL 
### 输出SQL语句调试日志
log4j.logger.org.hibernate.SQL=ERROR 

###   log   JDBC   bind   parameters   ### 
### 输出 JDBC参数查询的日志
#log4j.logger.org.hibernate.type=info 
log4j.logger.org.hibernate.type=ERROR 

###   log   schema   export/update   ### 
log4j.logger.org.hibernate.tool.hbm2ddl=ERROR 

###   log   HQL   parse   trees 
log4j.logger.org.hibernate.hql=ERROR

#log4j.logger.com.ibatis的日志级别要设置为info
log4j.logger.com.ibatis = DEBUG
log4j.logger.com.ibatis.common.jdbc.SimpleDataSource = ERROR   
log4j.logger.com.ibatis.common.jdbc.ScriptRunner = ERROR   
log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate = ERROR   
log4j.logger.java.sql.Connection = DEBUG
log4j.logger.java.sql.ResultSet = DEBUG
log4j.logger.java.sql.Statement = DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

log4j.logger.org.logicalcobwebs.proxool=ERROR
9.UserMapper.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.zhao.dao.UserMapper">
  <resultMap id="BaseResultMap" type="com.zhao.entity.User">
    <id column="user_id" jdbcType="INTEGER" property="userId" />
    <result column="user_name" jdbcType="VARCHAR" property="userName" />
    <result column="password" jdbcType="VARCHAR" property="password" />
    <result column="phone" jdbcType="VARCHAR" property="phone" />
  </resultMap>
  
  <sql id="Base_Column_List">
    user_id, user_name, password, phone
  </sql>
  
  <!-- 自己添加 -->
  <select id="selectAllUser" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from t_user
  </select>
  
  <!-- 自己添加 -->
  <select id="selectUserinfoByCondition"  resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from t_user where user_name = #{userName,jdbcType=VARCHAR}
  </select>
  
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from t_user
    where user_id = #{userId,jdbcType=INTEGER}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
    delete from t_user
    where user_id = #{userId,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.zhao.entity.User">
    insert into t_user (user_id, user_name, password, 
      phone)
    values (#{userId,jdbcType=INTEGER}, #{userName,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, 
      #{phone,jdbcType=VARCHAR})
  </insert>
  <insert id="insertSelective" parameterType="com.zhao.entity.User">
    insert into t_user
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="userId != null">
        user_id,
      </if>
      <if test="userName != null">
        user_name,
      </if>
      <if test="password != null">
        password,
      </if>
      <if test="phone != null">
        phone,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="userId != null">
        #{userId,jdbcType=INTEGER},
      </if>
      <if test="userName != null">
        #{userName,jdbcType=VARCHAR},
      </if>
      <if test="password != null">
        #{password,jdbcType=VARCHAR},
      </if>
      <if test="phone != null">
        #{phone,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.zhao.entity.User">
    update t_user
    <set>
      <if test="userName != null">
        user_name = #{userName,jdbcType=VARCHAR},
      </if>
      <if test="password != null">
        password = #{password,jdbcType=VARCHAR},
      </if>
      <if test="phone != null">
        phone = #{phone,jdbcType=VARCHAR},
      </if>
    </set>
    where user_id = #{userId,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.zhao.entity.User">
    update t_user
    set user_name = #{userName,jdbcType=VARCHAR},
      password = #{password,jdbcType=VARCHAR},
      phone = #{phone,jdbcType=VARCHAR}
    where user_id = #{userId,jdbcType=INTEGER}
  </update>
  
  
</mapper>
10.UserController 

package com.zhao.controller;

import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import com.zhao.entity.User;
import com.zhao.service.impl.UserServiceImpl;


@RestController
@RequestMapping("useraction")
public class UserController {

    @Resource
    private UserServiceImpl userService;
    
    private static Logger log = Logger.getLogger(UserController.class);
	
    @RequestMapping(params = "method=login")
    public ModelAndView login(String username,String password,HttpServletRequest request) {
    	
    	log.info("获取到的用户名是："+username+",用户密码是："+password);
    	
    	long i = System.currentTimeMillis();
    	
    	log.info("查询数据<<<开始>>>，当前时间是："+i);
    	
    	User user = userService.selectUserinfoByCondition(username);
    	
    	log.info("用户名："+username+"密码："+user.getPassword()+"手机号："+user.getPhone());
    	
    	List<User>	userList = userService.findAllUser();
    	
    	long y = System.currentTimeMillis();
    	log.info("查询数据<<<结束>>>，当前时间是："+y+",总共耗时："+(y-i));
    	
    	log.info("查询出来的集合大小为："+userList.size());
    	
    	ModelAndView model = new ModelAndView("page/login");
    	
    	model.addObject("admin", username);
    	model.addObject("doyou", "登陆超时就会自动退出该系统，请合理安排时间");
    	
    	return model;
    }
    
    
}
11.UserMapper 

package com.zhao.dao;

import java.util.List;

import com.zhao.entity.User;


public interface UserMapper {
	
	
    int deleteByPrimaryKey(Integer userId);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer userId);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);
    
    List<User> selectAllUser();
    
    User selectUserinfoByCondition(String username);
    
    
    
    
    
}
12.User 

package com.zhao.entity;

public class User {
    private Integer userId;

    private String userName;

    private String password;

    private String phone;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName == null ? null : userName.trim();
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password == null ? null : password.trim();
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone == null ? null : phone.trim();
    }

	public User() {
		
	}

	public User(Integer userId, String userName, String password, String phone) {
		super();
		this.userId = userId;
		this.userName = userName;
		this.password = password;
		this.phone = phone;
	}
    
    
    
}
13.UserService 
package com.zhao.service;

import java.util.List;

import com.zhao.entity.User;

public interface UserService {

	
	int addUser(User user);

    List<User> findAllUser();
    
    User selectUserinfoByCondition(String username);
	
}
14.UserServiceImpl 

package com.zhao.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.zhao.dao.UserMapper;
import com.zhao.entity.User;
import com.zhao.service.UserService;

//@Transactional //这里可加入事务控制
@Service
public class UserServiceImpl implements UserService{


	@Resource
	private UserMapper userMapper;
	
	public int addUser(User user) {
		
		return userMapper.insertSelective(user);
	}

	
	public List<User> findAllUser() {
		
	    List<User> userList = userMapper.selectAllUser();
	    
	    return userList;
	}


	
	public User selectUserinfoByCondition(String username) {
		
		return userMapper.selectUserinfoByCondition(username);
	}      

	
	
}
15.数据库表结构及数据 

/*
Navicat MySQL Data Transfer

Source Server         : mysql
Source Server Version : 50615
Source Host           : localhost:3306
Source Database       : zhaochunjian

Target Server Type    : MYSQL
Target Server Version : 50615
File Encoding         : 65001

Date: 2018-01-06 18:21:17
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  `phone` varchar(255) NOT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of t_user
-- ----------------------------
INSERT INTO `t_user` VALUES ('1', '张三', '123456', '13897971153');
INSERT INTO `t_user` VALUES ('2', '李四', '654321', '15281142336');
INSERT INTO `t_user` VALUES ('3', '王五', '123', '13897971153');
INSERT INTO `t_user` VALUES ('4', '钱六', '456', '18200158350');
16.以上步骤就很简单的建立了一个ssm整合的项目，该项目的简单功能是通过页面登录然后去数据库查询到相关数据。

启动项目，输入访问地址：http://localhost:8080/ssm  即可。出现下图画面则说明成功。

17.项目源码下载地址：http://download.csdn.net/download/qq_36348637/10191987

18. 提升：spring+springMVC+Mybatis+MYSQL+Redis+Maven项目整合源码下载地址：http://download.csdn.net/download/qq_36348637/10192031






 


前方的那片云
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合SpringMVC+Mybatis+Maven
Vinnie.Wu的博客
12-28 1490
关于微服务的相关知识这里就不介绍了，百度上很多文章都有详细的说明，这里主要介绍微服务框架的基础组件SpringBoot项目的构建，帮助大家快速上手学习，同时自己也是刚接触这方面的内容，如有不当，欢迎指教，谢谢！ 这里先说明一下，本demo采用的数据库是SQL SERVER数据库，其他数据库亦可。（PS：吐槽一下，SQL SERVER整合还是挺麻烦的，不推荐）具体步骤如下： 第一步：自己构建一个...
Spring+SpringMVC+Mybatis（ssm）项目整合
灰太狼
03-17 1326
1.构建项目包结构2.配置各种xml文件：1.pom.xml(依赖jar包配置文件）2.web.xml（网页请求配置文件）3.applicationContext.xml(spring容器文件）4.springmvc-config.xml(springmvc控制器配置）5.mybatis-config.xml(持久层文件，连接数据库）6.db.properties(数据库配置信息）7.log4j....
详细，maven整合Spring+SpringMVC+MyBatis
weixin_42556267的博客
06-27 2331
spring+spring MVC+MyBatis整合
SpringMVC+Mybatis+Maven搭建
m0_37027631的博客
12-01 598
本文概述：首先讲解了一下springMVC、Mybatis、Maven等一些相关知识点，然后详细介绍maven环境变量的配置、Mybatis-Generator工具类使用、eclipse中maven的集成、本地Maven仓库路径修改，之后介绍了eclipe中搭建SpringMVC+Mybatis+Maven的详细步骤及演示实例，最后是在框架搭建中遇到的一些问题。 代码实例资源下载地址：http:
springMVC+mybatis+maven框架搭建
hunanhlm的专栏
02-08 369
怕忘记搭建步骤如下； 1.新建 项目新建完成 我们看到jsp页面在报错，我们只要配置jdk和tomcat就好了 2.点击项目build path配置jdk1.8,tomcat 8.5 3.新增文件夹src/test/resorces,因为框架一般有4个，所以我们需要手动添加一个 tes 4.删除web.xml因为版本太低了，然后重新配置一个，如下 把勾去掉，点击apply,然后勾上选择2.5，然后配置web.xml 5.pom.xml配置引...
SpringMVC+Mybatis+Maven框架搭建
点点的博客
01-23 531
注：关于maven项目如何创建等一些基本问题，本文章中不说，只讲述项目的环境搭建，本人使用的idea 首先先说明一下项目包层次管理： 总体图 展开图①是这样滴 展开图②是这样滴 1.pom.xml文件 它主要是引入的jar包（我选的这些jar一般的功能都能实现）： xmlns="http://maven.apache.org/POM/4.0.0" xm
springMVC+Mybatis+maven实例
DailyLife
08-12 518
现在的java框架已经从SSH（spring+struts+Hibernate）过渡到了SSM（spring+springmvc+mybatis）。因为工作上用到的并不是spring框架，所以对spring并不是很熟悉，最近整理了一下以前的笔记，稍微再熟悉熟悉spring框架。 此次建立实例用到的是IntelliJ IDEA，应用maven来构建springmvc+mybatis+pos...
Spring+springMVC+Mybatis+Maven项目
10-12
【Spring+SpringMVC+Mybatis+Maven项目】是一个典型的Java Web开发框架组合，用于构建高效、可扩展的企业级应用程序。在这个项目中，Spring作为核心容器管理组件，SpringMVC处理HTTP请求和响应，Mybatis则负责数据库...
spring+springMVC+Mybatis+maven框架
02-24
SSM+Maven框架整合是Java Web开发中常见的技术栈，由Spring、SpringMVC、Mybatis和Maven四个核心组件组成。这篇文章将详细介绍这四个组件及其整合过程，旨在帮助开发者快速搭建一个可运行的Web项目。 **Spring框架*...
Spring+SpringMVC+Mybatis+Maven+bootstrap+ajax+jQuery整合开发简单的员工后台管理系统
05-08
在本项目中，"Spring+SpringMVC+Mybatis+Maven+bootstrap+ajax+jQuery整合开发简单的员工后台管理系统"，我们看到一个基于Java技术栈的Web应用开发实例。这个系统利用了多个核心技术来构建一个功能完备的员工管理...
SpringMvc+Spring+Mybatis+Maven整合示例源码
09-20
SpringMvc+Spring+Mybatis+Maven整合示例源码，可以直接导入IDE启动
Spring+SpringMVC+MyBatis+Maven+easyUI整合代码
03-02
Spring+SpringMVC+MyBatis+Maven+easyUI整合代码
springmvc+mybatis+maven框架
05-23
框架自己搭建的，可以直接使用，只需要换自己的数据库就可以
SpringMVC+Mybatis+Maven搭建代码实例
12-01
SpringMVC+Mybatis+Maven搭建实例以及Mybatis-Generator工具类
Maven+SpringMVC+Mybatis项目搭建示例完整版
07-27
基于Maven搭建Spring+Mybatis的项目，包含Maven聚合和继承、Mybatis增删改查和分页、SpringMVC开发及使用拦截器检查登录等知识点。详细介绍 http://blog.csdn.net/autfish/article/details/52037354
SSM框架（Spring+SpringMVC+MyBatis）+shiro+Maven.zip
03-14
● 实现方法： 使用MySQL 建立数据库。服务端使用SSM框架（Spring+SpringMVC+MyBatis）+shiro+Maven，使用Myeclipse进行开发。前端使用MUi和HUI框架和vue（与后台交互模板）和Html5+css3来实现移动端App的开发。
spring+springmvc+mybatis+maven入门实战(超详细教程)
08-26
Spring+SpringMVC+MyBatis+maven 入门实战超详细教程 本文主要介绍了 Spring+SpringMVC+MyBatis+maven 入门实战的超详细教程，涵盖了从新建 Maven 项目到 Maven 配置、Spring 配置、MyBatis 配置等内容。 一、新建...
Spring+Spring MVC+Mybatis+Maven整合教程(图文详解附代码)
jokeMqc的博客
08-07 323
1.配置整合前所需准备的环境:    这是我搭建的时候用的环境，至于环境的搭建我就不带大家搭建了，百度上一大堆教程 1.1：jdk1.8 1.2：idea2018.1.5 1.3：Maven 3.5.2 2.查看idea中是否安装Maven插件: 2.1：File --&gt; Settings --&gt; Plugins 2.2：如下图所示的步骤进行操作(注:安装完插件，ide...
SpringMVC+MyBatis+Maven 完整项目
06-14
开发环境STS，项目完整，只需修改数据库连接配置文件即可，数据库表创建文件已给出。
springmvc+maven+mybatis.doc
11-15
"该文档是关于如何在IntelliJ IDEA中使用Spring MVC、Maven和MyBatis进行项目集成的指南。它包含了项目的基本文件结构、`web.xml`的配置以及Spring上下文的加载设置。" 在Java Web开发中，Spring MVC、Maven和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值