2、Spring技术栈-整合Mybatis

最新推荐文章于 2024-04-14 07:55:13 发布

RonTech

最新推荐文章于 2024-04-14 07:55:13 发布

阅读量1.4k

点赞数

分类专栏： Spring Web开发实战 Spring Web开发实战专栏文章标签： spring mybatis

本文链接：https://blog.csdn.net/zyhlwzy/article/details/77675595

版权

Spring Web开发实战专栏同时被 2 个专栏收录

14 篇文章 6 订阅

订阅专栏

Spring Web开发实战

13 篇文章 0 订阅

订阅专栏

在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>

        <!-- Javax 依赖 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet_version}</version>
        </dependency>

        <!-- Spring 依赖 -->
        <!-- spring的核心包，包含spring框架基本的核心工具类，spring其它组件要都要使用到这个包里的类，是其它组件的基本核心。包括asm，cglib以及相关的工具类 -->
        <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>
        <!-- spring 整合第三方的 orm 映射支持，如 hibernate 、ibatis、jdo 以及spring的jpa的支持。 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency 
            Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring-beans.jar文件就可以了。 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类。 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring-context 的扩展支持，用于 MVC 方面 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring 对Object/XML 的映射的支持，可以让JAVA与XML之间来回切换。 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring提供对事务的支持，事务的相关处理以及实现类就在这个Jar包中 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative 
            Transaction Management），也要在应用里包含这个jar包。 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 提供对AspectJ的支持，以便可以方便的将面向方面的功能集成进IDE中 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring对JUnit框架的简单封装。 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- json数据 -->
        <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>

        <!-- LOGGING begin -->
        <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>
        <!-- common-logging 实际调用slf4j -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- java.util.logging 实际调用slf4j -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jul-to-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- LOGGING end -->
    </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>
        <!--依赖blog-domain模块 -->
        <dependency>
            <groupId>ron.blog</groupId>
            <artifactId>blog_domain</artifactId>
            <version>${project.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.3.0</version>
        </dependency>
        <!-- 导入Mysql数据库链接jar包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.connector.version}</version>
        </dependency>
        <!-- dbcp数据源 -->
         <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>
        <!-- 添加对Service的依赖 -->
        <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>

        <!-- Spring 依赖 -->
        <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>

        <!-- jstl依赖 -->
        <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文件，写入如下内容：

<?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:aop="http://www.springframework.org/schema/aop" 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/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd"
    default-autowire="byName" default-lazy-init="false">

    <!-- 采用注释的方式配置bean -->
    <context:annotation-config />

    <!-- 配置要扫描的包 -->
    <context:component-scan base-package="ron.blog" />

    <!-- jdbc配置 -->
    <context:property-placeholder location="classpath:mybatis/jdbc.properties" />

    <!-- proxy-target-class默认"false",更改为"ture"使用CGLib动态代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true" /> 

    <!-- 导入Mybatis配置 -->
    <import resource="classpath:mybatis/spring-mybatis.xml" />

</beans>

从配置的内容中我们就可以看到，我们将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}" />  
         <!-- 缓存preparedStatement数量 -->
         <property name="maxOpenPreparedStatements" value="${dataSource.maxOpenPreparedStatements}" />
         <!-- 打开removeAbandoned功能（对于建立时间超过removeAbandonedTimeout的连接强制关闭） -->
         <property name="removeAbandoned" value="${dataSource.removeAbandoned}" />
         <!-- 1800秒，也就是30分钟 -->
         <property name="removeAbandonedTimeout" value="${dataSource.removeAbandonedTimeout}" />
         <!-- 关闭abanded连接时输出错误日志 -->   
         <property name="logAbandoned" value="${dataSource.logAbandoned}" />
    </bean>

    <!-- mybatis的配置文件 -->
    <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。

这里写图片描述

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

这里写图片描述

然后在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

这里写图片描述

写入如下代码：

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

接下来我们在blog_service包中新建user包，在包中新建UserBaseService类。

这里写图片描述

该类实现接口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/，如果出现如下结果就证明我们的Spring和Mybatis的整合已经成功了。

这里写图片描述

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

RonTech

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
2、Spring技术栈-整合Mybatis

在1、Spring技术栈-博客系统基础架构中，我们基本上已经搭建好了博客系统的基本框架，但系系统，是需要链接数据库，和数据库进行数据交换的，所以本文我们将会告诉大家，在一个模块化的项目中，我们如何整合Spring+Mybatis来连接数据库并进行数据交换。首先我们需要说明的是，我们数据库采用的MySQL。1、SSM框架必备的依赖和解释 spring-core ：spring的核心包，包含spri
复制链接

扫一扫