2、Spring技术栈-整合Mybatis

ゝ一世哀愁。 2022-06-09 05:48 152阅读 0赞

在[1、Spring技术栈-博客系统基础架构][1_Spring_-]中，我们基本上已经搭建好了博客系统的基本框架，但系系统，是需要链接数据库，和数据库进行数据交换的，所以本文我们将会告诉大家，在一个模块化的项目中，我们如何整合Spring+Mybatis来连接数据库并进行数据交换。

首先我们需要说明的是，我们数据库采用的MySQL。

**1、SSM框架必备的依赖和解释**

> **spring-core** ：spring的核心包，包含spring框架基本的核心工具类，spring其它组件要都要使用到这个包里的类，是其它组件的基本核心。包括asm，cglib以及相关的工具类
> 
> **spring-orm** ： spring 整合第三方的 orm 映射支持，如 hibernate 、ibatis、jdo 以及spring的jpa的支持
> 
> **spring-beans** ： 这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。
> 
> **spring-context** : 这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类；
> 
> **spring-context-support** ： spring-context 的扩展支持，用于 MVC 方面；
> 
> **spring-oxm**：spring 对Object/XML 的映射的支持，可以让JAVA与XML之间来回切换；
> 
> **spring-tx** ： spring提供对事务的支持，事务的相关处理以及实现类就在这个Jar包中；
> 
> **spring-jdbc** ： 这个jar文件包含对Spring对JDBC数据访问进行封装的所有类；
> 
> **spring-aop** ： 这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。
> 
> **spring-aspects** ： 提供对AspectJ的支持，以便可以方便的将面向方面的功能集成进IDE中；

在Web MVC项目中还需要有一下几个依赖

> **spring-web** : 这个jar 文件包含Web 应用开发时，用到Spring 框架时所需的核心类，包括自动载入Web ApplicationContext 特性的类、Struts 与JSF 集成类、文件上传的支持类、Filter 类和大量工具辅助类，外部依赖spring-context, Servlet API, (JSP API, JSTL,Commons FileUpload, COS)；
> 
> **spring-webmvc** : 这个jar 文件包含Spring MVC 框架相关的所有类。包括框架的Servlets，Web MVC框架，控制器和视图支持。当然，如果你的应用使用了独立的MVC 框架，则无需这个JAR 文件里的任何类。

以上的这些是对Spring的依赖，除此之外，系统还需要依赖Mybatis核心包、mybatis/spring包、Mysql数据库链接jar包、dbcp数据源所依赖的一些包，这里我们就不一一列举了，在配置dao层的pom.xml文件时我们会加以说明；

**2、父级项目pom.xml配置**

在我们上诉的所有依赖中，除了spring-web和spring-webmvc是web项目独有的依赖之外，其他的基本上是每个模块都必须依赖的，而所有模块都需要依赖的jar呢，我们就不用一个一个的配置在不同模块，我们直接配置到父级项目的pom.xml中，子模块直接从父级项目继承就可以了。

<?xml version="1.0" encoding="UTF-8"?>
    <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>ron.blog</groupId>
        <artifactId>blog</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>pom</packaging>
    
        <name>blog</name>
        <url>http://maven.apache.org</url>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    
            <spring.version>4.3.5.RELEASE</spring.version>
            <jdk.version>1.8</jdk.version>
            <jstl.version>1.2</jstl.version>
            <junit.version>3.8.1</junit.version>
            <slf4j.version>1.7.21</slf4j.version>
            <servlet_version>3.1.0</servlet_version>
            <mybatis.version>3.4.1</mybatis.version>
            <mysql.connector.version>6.0.5</mysql.connector.version>
            <commons_pool_version>1.6</commons_pool_version>
            <jackson.version>1.9.13</jackson.version>
            <log4j2_version>2.7</log4j2_version>
            <dbcp.version>1.4</dbcp.version>
        </properties>
    
        <modules>
            <module>blog_domain</module>
            <module>blog_dao</module>
            <module>blog_service</module>
            <module>blog_pc</module>
            <module>blog_facade</module>
            <module>blog_common</module>
            <module>blog_api</module>
        </modules>
    
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
    
            
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${servlet_version}</version>
            </dependency>
    
            
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>commons-logging</groupId>
                        <artifactId>commons-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</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-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-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-aop</artifactId>
                <version>${spring.version}</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.codehaus.jackson</groupId>
                <artifactId>jackson-core-asl</artifactId>
                <version>${jackson.version}</version>
            </dependency>
            <dependency>
                <groupId>org.codehaus.jackson</groupId>
                <artifactId>jackson-mapper-asl</artifactId>
                <version>${jackson.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>${log4j2_version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-api</artifactId>
                <version>${log4j2_version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-web</artifactId>
                <version>${log4j2_version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>jcl-over-slf4j</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>jul-to-slf4j</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            
        </dependencies>
        <build>
    
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.3</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
        <profiles>
            <profile>
                <id>jdk-1.8</id>
                <activation>
                    <jdk>${jdk.version}</jdk>
                </activation>
                <properties>
                    <maven.compiler.source>${jdk.version}</maven.compiler.source>
                    <maven.compiler.target>${jdk.version}</maven.compiler.target>
                    <maven.compiler.compilerVersion>${jdk.version}</maven.compiler.compilerVersion>
                </properties>
            </profile>
        </profiles>
    </project>

**3、dao层依赖配置**

在我们模块化的应用中，为了更清晰的区分哪些依赖用在那一层，所以呢我们就按照每一层所负责的逻辑，将只有该层才使用的依赖配到该模块。所以我们将和Mybatis、MySQL数据库链接、dbcp数据源相关的依赖都配置在dao层。

<?xml version="1.0"?>
    <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>ron.blog</groupId>
            <artifactId>blog</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <artifactId>blog_dao</artifactId>
        <packaging>jar</packaging>
    
        <name>blog_dao</name>
        <url>http://maven.apache.org</url>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
        <dependencies>
            
            <dependency>
                <groupId>ron.blog</groupId>
                <artifactId>blog_domain</artifactId>
                <version>${project.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.3.0</version>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.connector.version}</version>
            </dependency>
            
             <dependency>  
                <groupId>commons-dbcp</groupId>  
                <artifactId>commons-dbcp</artifactId>  
                <version>${dbcp.version}</version>  
            </dependency> 
            <dependency>
                <groupId>commons-pool</groupId>
                <artifactId>commons-pool</artifactId>
                <version>${commons_pool_version}</version>
            </dependency>
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>3.2.2</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>3.8.1</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </project>

**4、web层依赖配置**

除了父级项目的基础依赖之外，web层仅仅只需要配置一下spring-web、spring-webmvc、jstl的依赖就可以了。

<?xml version="1.0"?>
    <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>ron.blog</groupId>
            <artifactId>blog</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
        <artifactId>blog_pc</artifactId>
        <packaging>war</packaging>
        <name>blog_pc Maven Webapp</name>
        <url>http://maven.apache.org</url>
        <dependencies>
            
            <dependency>
                <groupId>ron.blog</groupId>
                <artifactId>blog_service</artifactId>
                <version>${project.version}</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </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>jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
        </dependencies>
        <build>
            <finalName>blog_pc</finalName>
        </build>
    </project>

到这里，基本上我们整合Mybatis所需要的依赖包基本已经配置完毕，那么接下来我们就开始配置我们的参数。

**5、web上下文配置（spring-context）**

上一篇文章中，我们在配置web.xml时有提到，web应用程序上下文的初始化参数，我们都配置在classpath下的以spring-context开头的xml文件中，所以我们在resources目录下，新建spring-context.xml文件，写入如下内容：

从配置的内容中我们就可以看到，我们将jdbc的链接参数放到了classpath下的mybatis目录下一个叫jdbc.properties问属性文件中，所以我们需要在对应的目录下面新建对应的文件。

同时我们将Spring Mybatis相关的如事务、切点、切面等相关的内容都独立配置到了一个叫做 spring-mybatis.xml的文件中，也需要在对应的目录下新建一个spring-mybatis.xml文件。

**6、jdbc.properties的配置**

在jdbc.properties文件中，我们主要配置数据库的驱动名称、数据库连接、用户名、密码即可，其他参数可视具体情况而定。

#(Dev)
    dataSource.driverClassName=com.mysql.cj.jdbc.Driver
    dataSource.url=jdbc:mysql://127.0.0.1:3306/ron_intelligence_system(数据库名字，可自行定义)?useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=true&allowMultiQueries=true&serverTimezone=Asia/Hong_Kong
    dataSource.username=root（数据库账户）
    dataSource.password=111111（数据库密码）
    
    dataSource.maxActive=20
    dataSource.initialSize=5
    dataSource.maxWait=60000
    dataSource.minIdle=10
    
    dataSource.timeBetweenEvictionRunsMillis=60000
    dataSource.minEvictableIdleTimeMillis=300000
    
    dataSource.validationQuery=SELECT 'x'
    dataSource.testWhileIdle=true
    dataSource.testOnBorrow=false
    dataSource.testOnReturn=false
    
    dataSource.maxOpenPreparedStatements=20
    dataSource.removeAbandoned=true
    dataSource.removeAbandonedTimeout=1800
    dataSource.logAbandoned=true

**7、spring-mybatis.xml的配置**

在该文件中呢，我们所配置的东西就是和我们的数据库连接、Mybatis的mapper和对应的dao、事务管理器、切面等内容。

<?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:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-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/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
         <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
             
             <property name="url" value="${dataSource.url}" />  
             <property name="username" value="${dataSource.username}" />  
             <property name="password" value="${dataSource.password}" />  
             <property name="driverClassName" value="${dataSource.driverClassName}" />  
             
             <property name="maxActive" value="${dataSource.maxActive}" />
             
             <property name="initialSize" value="${dataSource.initialSize}" />
             
             <property name="maxWait" value="${dataSource.maxWait}" />
             
             <property name="minIdle" value="${dataSource.minIdle}" />  
             
             <property name="timeBetweenEvictionRunsMillis" value="${dataSource.timeBetweenEvictionRunsMillis}" />
             
             <property name="minEvictableIdleTimeMillis" value="${dataSource.minEvictableIdleTimeMillis}" />  
             <property name="validationQuery" value="${dataSource.validationQuery}" />  
             <property name="testWhileIdle" value="${dataSource.testWhileIdle}" />  
             <property name="testOnBorrow" value="${dataSource.testOnBorrow}" />  
             <property name="testOnReturn" value="${dataSource.testOnReturn}" />  
             
             <property name="maxOpenPreparedStatements" value="${dataSource.maxOpenPreparedStatements}" />
             
             <property name="removeAbandoned" value="${dataSource.removeAbandoned}" />
             
             <property name="removeAbandonedTimeout" value="${dataSource.removeAbandonedTimeout}" />
                
             <property name="logAbandoned" value="${dataSource.logAbandoned}" />
        </bean>
    
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <property name="mapperLocations" value="classpath:ron/blog/blog_dao/mapper/*/*.xml"/>
        </bean>
    
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="ron.blog.blog_dao.dao"/>
        </bean>
    
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource" />
        </bean>
    
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="insert*" propagation="REQUIRED"/>
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="save*" propagation="REQUIRED"/>
    
                <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
                <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
                <tx:method name="search*" propagation="SUPPORTS" read-only="true"/>
                <tx:method name="query*" propagation="SUPPORTS" read-only="true"/>
    
                <tx:method name="*" propagation="REQUIRED" />
                <tx:method name="*" rollback-for="java.lang.Exception"/>
            </tx:attributes>
        </tx:advice>
        <aop:config>
            <aop:pointcut id="txPointcut" expression="execution(* ron.blog.blog_service..*Service.*(..))" />
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
        </aop:config>     
    </beans>

到此为止，Spring和Mybatis的整合基本就完成了，根据我们所配置的内容，我们来写一个简单的例子测试一下。

**8、建立数据库和测试数据表**

我们先在MySQL新建一个数据库，按照我们的配置文件，我们命名为ron\_intelligence\_system，然后我们新建一张表，新建表的脚本为：

CREATE TABLE `blog_user_base` ( `ID` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '系统用户ID', `user_login_name` varchar(40) DEFAULT NULL COMMENT '用户登录名', `user_login_password` varchar(200) DEFAULT NULL COMMENT '用户登录密码', `user_realy_name` varchar(40) DEFAULT NULL COMMENT '用户真实姓名', `user_email` varchar(100) DEFAULT NULL COMMENT '用户邮箱', `user_phone` varchar(40) DEFAULT NULL COMMENT '用户手机', `user_position` varchar(100) DEFAULT NULL COMMENT '用户职位', `crt_time` datetime DEFAULT NULL COMMENT '创建用户时间', `crt_user_id` int(11) DEFAULT NULL COMMENT '创建者Id', `crt_user_name` varchar(40) DEFAULT NULL COMMENT '创建者姓名', `crt_ip` varchar(40) DEFAULT NULL COMMENT '创建ip', `last_mid_time` datetime DEFAULT NULL COMMENT '最后一次变更时间', `last_mid_user_id` int(11) DEFAULT NULL COMMENT '最后一次变更id', `last_mid_user_name` varchar(40) DEFAULT NULL COMMENT '最后一次变更姓名', `last_mid_ip` varchar(200) DEFAULT NULL COMMENT '最后一次变更ip', PRIMARY KEY (`ID`) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8；

新建好数据表之后，我们随便写入一条数据。  
我们测试数据呢，user\_login\_name写入632815143@qq.com，user\_login\_password写入0794f55dcaada3f45c9436b7a11dfdaf2cf82176，user\_email写入632815143@qq.com，我们测试时根据user\_login\_name和user\_login\_password来读取user\_email。

**9、新建实体和dao**

在blog\_domain模块中，新建user包，在包中新建类BlogUserBase，BlogUserBase属性包括id、userLoginName、userLoginPassword、userEmail。

![这里写图片描述][SouthEast]

在blog\_dao模块中，在包ron.blog.blog\_dao下新建包dao和包mapper，在dao包中新建一个user包，在包mapper中新建包user

![这里写图片描述][SouthEast 1]

然后在user包中新建接口BlogUserBaseDao，在接口之中写入一个login接口方法，代码如下：

BlogUserBase login(@Param("userLoginName")String userLoginName,@Param("userLoginPassword")String userLoginPassword);

在包mapper中新建包user，在user包中新建BlogUserBaseDao.xml，在该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="ron.blog.blog_dao.dao.user.BlogUserBaseDao">
        <resultMap id="userBaseResultMap" type="ron.blog.blog_domain.user.BlogUserBase">
            <id column="ID" property="id" />
            <result column="user_login_name" property="userLoginName" />
            <result column="user_login_password" property="userLoginPassword" />
            <result column="user_email" property="userEmail" />
        </resultMap>
    
        <sql id="Base_Column_List"> 
            ID,user_login_name,user_login_password,user_email
        </sql>
    
        <select id="login" parameterType="map" resultMap="userBaseResultMap">
            SELECT * FROM blog_user_base WHERE user_login_name=#{userLoginName} AND user_login_password=#{userLoginPassword}
        </select>
    </mapper>

好了，到目前为止我们的dao层的代码基本就写完了。

**10、编写服务模块代码**

在dao模块中的代码写好之后，我们在blog\_facade模块中新建一个包user，然后在包中新建一个接口UserBaseFacade

![这里写图片描述][SouthEast 2]

写入如下代码：

public interface UserBaseFacade { 
        /** * @Comment 用户登录接口 * @Author Ron * @Date 2017年8月22日 下午2:55:22 * @return */
        Resp login(BlogUserBase user);
    }

接下来我们在blog\_service包中新建user包，在包中新建UserBaseService类。

![这里写图片描述][SouthEast 3]

该类实现接口UserBaseFacade，代码如下：

@Component
    public class UserBaseService implements UserBaseFacade { 
    
        @Autowired
        BlogUserBaseDao blogUserBaseDao;
    
        /** * @Comment 用户登录实现 * @Author Ron * @Date 2017年8月22日 下午2:55:37 * @return */
        public Resp login(BlogUserBase user) {
            user = blogUserBaseDao.login(user.getUserLoginName(), user.getUserLoginPassword());
            return new Resp(ResCode.SUCCESS,"Hello"+user.getUserEmail());
        }
    }

以上我们就把dao、service都已经写完，那么接下来我们就写一个控制器，然后调用service的login方法，然后显示查询到的useremail到页面上。

**11、测试结果**

新建BlogController控制器，写入如下代码：

@Controller
    @RequestMapping("/blog")
    public class BlogController{ 
    
        @Autowired
        UserBaseFacade userBaseService;
    
        /** * @Comment 博客列表 * @Author Ron * @Date 2017年8月22日 下午3:54:38 * @return */
        @RequestMapping(value={
       "/list","/"})
        public String blogList(HttpServletRequest request) {
            BlogUserBase user = new BlogUserBase();
            user.setUserLoginName("632815143@qq.com");
            user.setUserLoginPassword("0794f55dcaada3f45c9436b7a11dfdaf2cf82176");
    
            Resp resp = userBaseService.login(user);
            request.setAttribute("resp", resp);
            return "blog/list";
        }
    }

在WEB-INF/view/blog新建一个list.jsp文件，写入如下代码：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!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>Insert title here</title>
    </head>
    <body>
        ${resp.data}
    </body>
    </html>

至此，我们所有的测试功能已经写完，运行blog\_pc，在浏览器中输入 [http://localhost:8080/blog\_pc/][http_localhost_8080_blog_pc]，如果出现如下结果就证明我们的Spring和Mybatis的整合已经成功了。

![这里写图片描述][SouthEast 4]

整个项目源码：[https://github.com/Ron-Zheng/blog-system][https_github.com_Ron-Zheng_blog-system]  
单独整合Mybatis的源码：[http://download.csdn.net/download/zyhlwzy/9947175][http_download.csdn.net_download_zyhlwzy_9947175]

[1_Spring_-]: http://blog.csdn.net/zyhlwzy/article/details/77584553
[SouthEast]: /images/20220609/dba1de2925444b75b79de6bfd596c4b1.png
[SouthEast 1]: /images/20220609/e61b7d0b99fb4e94ba8dee504168932b.png
[SouthEast 2]: /images/20220609/b1abcf44f6da4d788c7ffca53347f2e8.png
[SouthEast 3]: /images/20220609/62302ca42015459f99f5c68fbfbd56eb.png
[http_localhost_8080_blog_pc]: http://localhost:8080/blog_pc/
[SouthEast 4]: /images/20220609/0c6351b321944247a9d59809d328c460.png
[https_github.com_Ron-Zheng_blog-system]: https://github.com/Ron-Zheng/blog-system
[http_download.csdn.net_download_zyhlwzy_9947175]: http://download.csdn.net/download/zyhlwzy/9947175