spring、spring mvc、mybatis框架整合基本知识

学习了一个多月的框架知识了，这两天很想将它整合一下。网上看了很多整合案例，基本都是基于Eclipse的，但现在外面公司基本都在用Intellij IDEA了，所以结合所学知识，自己做了个总结，有不足之处欢迎指正。

首先，我是参考了http://blog.csdn.net/zhshulin/article/details/37956105这篇做的Intellij IDEA翻版。Intellij IDEA的许多操作方式与习惯与eclipse区别很大，所以很容易走入误区。直接上操作吧。

1、基本概念

1.1、Spring

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

1.2、SpringMVC

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

1.3、MyBatis

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

首先，先来吧基本依赖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>BosSearch</groupId>
  <artifactId>bos</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>bos Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <properties>
    <!-- spring版本号 -->
    <spring.version>4.0.2.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.2.6</mybatis.version>
    <!-- log4j日志文件管理包版本 -->
    <slf4j.version>1.7.7</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.6</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <!-- 表示开发的时候引入，发布的时候不会加载此包 -->
      <scope>test</scope>
    </dependency>
    <!-- spring核心包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- mybatis核心包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!-- mybatis/spring包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- 导入java ee jar 包 -->
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
    </dependency>
    <!-- 导入Mysql数据库链接jar包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.30</version>
    </dependency>
    <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- JSTL标签类 -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- 日志文件管理包 -->
    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <!-- 格式化对象，方便输出日志 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.1.41</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <!-- log end -->
    <!-- 映入JSON -->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.13</version>
    </dependency>
    <!-- 上传组件包 -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
    <dependency>
      <groupId>commons-codec</groupId>
      <artifactId>commons-codec</artifactId>
      <version>1.9</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>

  </dependencies>
  <build>
    <finalName>bos</finalName>
    <plugins>
      <plugin>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.3.2</version>
        <configuration>
          <verbose>true</verbose>
          <overwrite>true</overwrite>
        </configuration>
      </plugin>
    </plugins>
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <excludes>
          <exclude>**/*.java</exclude>
        </excludes>
      </resource>
    </resources>
  </build>
</project>

　

请大家注意最后的<resources>这是为了防止编译时无法编译xml文件的一个配置。大家应该知道，xml文件，intellij一般推荐我们放到下图位置：

所以对于源码目录下的xml，它是默认不编译的，所以最好这也配置！

另外，还有一些其它jar包，我是自己导入的，大家先试着做，慢慢再来准备需要的，也有可能不需要，忘记包是自己一次性加上了的了！

2、配置文件功能说明

总共需要放置6个配置文件，分别是：

1、generatorConfig.xml  （mybatis逆向工程配置文件）

2、jdbc.properties            (数据库连接参数配置文件，用作统一管理)

3、log4j.properties           （日志打印配置文件）

4、spring-mvc.xml             （视图层配置文件）

5、spring-mybatis.xml        （spring与mybatis整合配置文件）

6、web.xml                        （处理客户端请求地址映射，交给spring mvc来管理）

接下来分别对几个文件做详细说明：（不按上述顺序吧，按照一般思路来，先别乱）

2.1 web.xml配置文件

这是我们web应用程序的入口，具体怎么解释，这里就不累赘了，网上一大堆，反正我的理解是这是sun公司提供给其它框架发挥作用的一个通道。先来看看配置吧。

此文件一般在webapp\WEB-INF\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"
         version="3.0">
  <display-name>Archetype Created Web Application</display-name>
  <!-- Spring和mybatis的配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mybatis.xml</param-value>
  </context-param>
  <!-- 编码过滤器 -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <async-supported>true</async-supported>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!-- Spring监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 防止Spring内存溢出监听器 -->
  <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  </listener>

  <!-- Spring MVC servlet -->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>

</web-app>

　　

基本用法也在代码里面说明，就是要让我们的spring mvc配置文件产生作用。

2.2 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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
    <!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
    <mvc:annotation-driven />
    <context:component-scan base-package="com.liyong.bos.controller" />
    <!--避免IE执行AJAX时，返回JSON出现下载文件 -->
    <bean id="mappingJacksonHttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <!-- 启动SpringMVC的注解功能，完成请求和注解POJO的映射 -->
    <bean
            class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJacksonHttpMessageConverter" /> &lt;!&ndash; JSON转换器 &ndash;&gt;
            </list>
        </property>
    </bean>
     <!--定义跳转的文件的前后缀 ，视图模式配置-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
        <property name="prefix" value="/pages/" />
        <property name="suffix" value=".html" />
    </bean>
    <!--下面的配置尤为重要，否则我们无法访问到静态文件，无法进行跳转-->
    <mvc:resources mapping="/pages/**" location="/pages/" />
    <mvc:resources mapping="/css/**" location="/css/" />
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/easyui/**" location="/easyui/" />
    <mvc:resources mapping="/js/**" location="/js/" />
    <!-- 配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包 -->
    <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>

</beans>

注释掉了一部分内容，因为相关依赖包的版本与之前那位博主的版本不一样，所以有些功能无法使用，也注掉了一部分个人认为无大碍的配置。大家可以试着解开注释。这个文件的注意功能也就是扫描视图层那些注解，考虑到目前公司里的项目基本都用注解的这个趋势，也就没必要写一大串的配置，那样反而显得很复杂。

2.3 spring-mybatis.xml配置文件

这个文件的作用首先就是扫描我们通过mybatis逆向工程所生成的mapper.xml和po类和dao层接口。在没接触到逆向工程的时候，还真不知道别人是怎么通过访问一个接口就实现了数据库的操作的，知道了之后才知道，这个用起来真的很爽。

首先，先解释一下什么是mybatis逆向工程：

Mybatis提供来一个逆向工程工具，通过逆向工程，可以帮助程序员根据单表来生成po类、mapper映射文件、mapper接口。

是不是很不解？先别急，听我简单解释一下。先来看张图：

请大家注意，这些都是直接生成的，也就是说整个项目，我们不需要写任何sql语句，而且还能达到性能优化的目的。

此时，一定很想知道怎么生成的对不，先别急，先讲解一下基本用处。

dao层，这个显然是持久层，但是细心的你有没有注意，这里只有接口，那么，实现类呢？

先别急，先看下面。domain很显然是po类，也就是对应了数据库的字段的一个模型(不管遇到什么业务要求，这个po类千万别改，别问为什么，习惯问题。有很多其它处理方法，比如建vo类或者其它)

里面还有一个Example结尾的，这个先来看一小段代码（摘取一部分）：

protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public TUserExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

public Criteria andIdIsNotNull() {
            addCriterion("id is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(String value) {
            addCriterion("id =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(String value) {
            addCriterion("id <>", value, "id");
            return (Criteria) this;
        }

前面大家可能不太懂，直接看下面的andIdEqualTo(String value）这几个方法，字面上解释就是连接ID等于**很显然，这就是传一些条件给接下来的TUserMapper.xml里面的东西去拼接数据库语句，进而进行查询。好了，这里也解释了TUserMapper.xml的作用了，就是根据传入的条件去拼接数据库操作语句噻。具体那里面都是干什么的，大家还是去百度，涉及的东西比较多。

下面是一段代码：

<update id="updateByPrimaryKeySelective" parameterType="com.liyong.bos.domain.TUser" >
    update t_user
    <set >
      <if test="username != null" >
        username = #{username,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        password = #{password,jdbcType=VARCHAR},
      </if>
      <if test="salary != null" >
        salary = #{salary,jdbcType=DOUBLE},
      </if>
      <if test="birthday != null" >
        birthday = #{birthday,jdbcType=DATE},
      </if>
      <if test="gender != null" >
        gender = #{gender,jdbcType=VARCHAR},
      </if>
      <if test="station != null" >
        station = #{station,jdbcType=VARCHAR},
      </if>
      <if test="telephone != null" >
        telephone = #{telephone,jdbcType=VARCHAR},
      </if>
      <if test="remark != null" >
        remark = #{remark,jdbcType=VARCHAR},
      </if>
    </set>
    where id = #{id,jdbcType=VARCHAR}
  </update>

还是那句，大家去百度找学习资料，方便大家以后排错，当然这样的几率很小。

至此，逆向工程讲解完毕。

接下来将逆向工程怎么生成代码：直接上代码了

首先，得引入jar包，当然，已经在pom里面配置了

然后测试类和xml配置文件：

测试类：大家仅需要更改file路径即可！

package test;

import org.junit.Test;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by ApacheMoy on 2017/4/6.
 */
public class Gen {
    @Test
    public void product() throws Exception {
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        File configFile = new File("E:\\project\\bos\\src\\main\\resources\\generatorConfig.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                callback, warnings);
        myBatisGenerator.generate(null);
    }
}

2.4 generatorConfig.xml配置文件

这个文件是对我们需要操作的数据库进行配置，需要列出表名！

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

    <classPathEntry location="E:\project\Mylib\bos\mysql-connector-java-5.1.7-bin.jar"/>
    <context id="testTables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection
                driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/bos_system" userId="root"
                        password="root">
        </jdbcConnection>
        <!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver" connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg"
            userId="yycg" password="yycg"> </jdbcConnection> -->

        <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL
            和 NUMERIC 类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator targetPackage="com.liyong.bos.domain"
                            targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="com.liyong.bos.mapper"
                         targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.liyong.bos.dao" targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>

        <!-- 指定数据库表 -->
        <table tableName="t_user"></table>
    </context>
</generatorConfiguration>

请大家一定要注意下图标记的部分，这也是与eclipse的重大区别！

由于习惯，我们通常会将java目录设置为源码目录来存放编译的文件，但eclipse通常情况下仅仅就是src。为什么要区别这两点，很重要！如果目录不对，生成的地方也不会对，进而里面的代码配置也会有区别，最后肯定会出错，所以，大家尽量别生成在其它地方而又拷贝进来，那样运行起来会出错的！

接下来把jdbc配置文件补上！

2.5 jdbc.properties配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/bos_system
username=root
password=root
#定义初始连接数
initialSize=0
#定义最大连接数
maxActive=20
#定义最大空闲
maxIdle=20
#定义最小空闲
minIdle=5
#定义最长等待时间
maxWait=60000

接下来是log4j配置文件，大家直接拷贝吧，我也是拷贝的

2.6 log4j.properties配置文件

#定义LOG输出级别
log4j.rootLogger=INFO,Console,File
#定义日志输出目的地为控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
#可以灵活地指定日志输出格式，下面一行是指定具体的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n

#文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.File = org.apache.log4j.RollingFileAppender
#指定输出目录
log4j.appender.File.File = logs/ssm.log
#定义文件最大大小
log4j.appender.File.MaxFileSize = 10MB
# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

至此，基本配置已经先这样了，可能有不完善的地方，还是建议大家先看下最开始说明的那篇博文！

接下来写个测试类试一下：

package test;

import com.liyong.bos.domain.TUser;
import com.liyong.bos.service.StaffService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.util.Date;

/**
 * Created by ApacheMoy on 2017/4/5.
 */
@RunWith(SpringJUnit4ClassRunner.class)     //表示继承了SpringJUnit4ClassRunner类
@ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
public class UserTest {
    @Resource
    private StaffService staffService;
    @Test
    public void testInsert() {
        TUser tUser = new TUser();
        tUser.setId("0testID");
        tUser.setUsername("liyongdada");
        tUser.setPassword("TC520");
        tUser.setSalary(60000.0);
        tUser.setBirthday(new Date(20131214));
        tUser.setGender("dd");
        tUser.setRemark("okk");
        tUser.setStation("ss");
        tUser.setTelephone("1234567");
        System.out.println("--------------" + staffService.insertUser(tUser));

    }
}

　　

service服务类：（md5码工具类网上也挺多，大家可用可不用，看看就好，根据自己情况来）

package com.liyong.bos.service;

import com.liyong.bos.dao.TUserMapper;
import com.liyong.bos.domain.TUser;
import com.liyong.bos.domain.TUserExample;
import com.liyong.bos.utils.MD5Util;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * Created by ApacheMoy on 2017/4/5.
 */
@Service("staffService")
public class StaffServiceImpl implements StaffService{
    @Autowired
    private TUserMapper tUserMapper;
/**
   * 用户登陆验证
    * */
    public TUser finUser(String username, String password){
        TUserExample tUserExample=new TUserExample();
        tUserExample.createCriteria().andUsernameEqualTo(username).andPasswordEqualTo(MD5Util.getMD5Str(password));
        List<TUser> list=tUserMapper.selectByExample(tUserExample);
        if (list != null && list.size() > 0) {
            return list.get(0);
        }
        return null;
    }

/**
    *用户注册
    * */
    public int insertUser(TUser tUser){
        tUser.setPassword(MD5Util.getMD5Str(tUser.getPassword()));
        return tUserMapper.insertSelective(tUser);
    }
   /**
    * 查询全部用户（分页按条件）
    * */
    public List<TUser> finAllUser(String userNameSearch, int start, int pageSize){
        TUserExample tUserExample=new TUserExample();
        tUserExample.setOrderByClause("id asc");
        tUserExample.setLimitStart(start);
        tUserExample.setLimitEnd(pageSize);
        if(StringUtils.isNotBlank(userNameSearch)){
            tUserExample.createCriteria().andUsernameLike(userNameSearch);
        }
        List<TUser> users=tUserMapper.selectByExample(tUserExample);
        if(users.size()>0){
            return users;
        }else
        return null;
    }

    /**
     * 更新用户信息，无设置信息则不更新
     * */
    public int updateUser(TUser tUser) {
        int isUpdate=0;
        if(StringUtils.isNotBlank(tUser.getId())) {
            isUpdate = tUserMapper.updateByPrimaryKey(tUser);
        }
        return isUpdate;
    }

    /**
     * 删除用户
     * */
    public int deleteUser(String id){
        int isDelete=0;
        if(StringUtils.isNotBlank(id)) {
            isDelete = tUserMapper.deleteByPrimaryKey(id);
        }
        return isDelete;
    }

}

大家可能会疑问，service怎么可以直接找dao的接口就行了，大家方向，已经在spring-mybatis.xml文件中配置了，具体在这里：

有注释，我就不解释啦。

先来看看测试代码效果吧，数据库====

另外不知道大家还有没有其它的疑问，可能是配置文件的，所以，这里我把我这次的项目结构图给大家！

至此，整合就先告一段落吧。如果大家想在Intellij IDEA中使用svn代码管理工具的话，请看这篇博文：

http://ylq365.iteye.com/blog/1955291