`

Spring回顾之三 —— MyBatis的加盟

springjavamysqlMyBatisorm 
阅读更多
    本篇将介绍如何引入帮助处理数据的MyBatis框架，对于普通的数据处理而言，MyBatis属于轻量级的数据持久层框架，使用起来简单上手，具体优缺点放下不说，我们先上手。
第一步：数据环境的准备和依赖的引入
    首先我们要准备下数据环境，当然这里不准备强调MySQL数据库怎么使用，前提假定我们已经安装好了数据库，并且也会做简单的操作，并能理解基本的SQL语言。我们需要创建一个数据库，作为对应起名为demo，然后创建一张作为测试的表，起名为d_user，创建代码如下 
DROP TABLE IF EXISTS d_user;
CREATE TABLE d_user (
  u_id int(11) NOT NULL,
  u_name varchar(255) DEFAULT NULL,
  u_password varchar(255) DEFAULT NULL,
  u_age int(11) DEFAULT NULL,
  PRIMARY KEY (u_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    然后我们在这张表里边手动填充一下数据，看起来大概就是这个样子
   

    好了，数据环境OK之后，我们要引入相关的jar包资源。
    在之前的项目基础上，我们看看，集成MyBatis都需要添加什么，首先MyBatis是直接基于jdbc的，所以spring-jdbc这个包是少不了的，然后还有必须的dao模块啊、驱动啊等等，修改pom文件，这部分MyBatis所涉及到的依赖代码代码如下 
		<!-- ============== orm begin ============== -->
		<dependency><!-- Spring对 JDBC数据访问进行封装的所有类  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>  
			<version>${spring.version}</version>  
		</dependency>
		<dependency><!-- 包含 Spring DAO、Spring Transaction 进行数据访问的所有类  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-dao</artifactId>
			<version>2.0.8</version>
		</dependency>
		<dependency><!-- mysql驱动  -->
			<groupId>mysql</groupId>  
			<artifactId>mysql-connector-java</artifactId>  
			<version>6.0.5</version>  
		</dependency>  
		<dependency><!-- Druid的数据库连接池，性能良好不错 -->
			<groupId>com.alibaba</groupId>  
			<artifactId>druid</artifactId>  
			<version>1.0.28</version>  
		</dependency>  
		<dependency><!-- mybatis -->  
			<groupId>org.mybatis</groupId>  
			<artifactId>mybatis</artifactId>  
			<version>3.4.1</version>  
		</dependency>
		<dependency><!-- Spring整合mybatis所需类包  -->
			<groupId>org.mybatis</groupId>  
			<artifactId>mybatis-spring</artifactId>  
			<version>1.3.0</version>  
		</dependency>
		<!-- ============== orm end ============== -->

    注意我们使用了阿里的druid数据连接池，这个在很多方面都表现了不错的性能优势，还可以配置资源监控等，具体以后再聊，由于考虑到maven会将一些所依赖的jar包自动引入，可能引起疑问，于是也将整个项目所需的重要jar包都在pom文件里显式的写出，顺便也再次熟悉下每个jar包大概的功能，这部分依赖就像下边的样子 
		<!-- ============== spring core begin ============== -->
		<dependency><!-- Spring框架基本的核心工具类  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency><!-- 访问配置文件、创建和管理bean以及进行IoC/DI操作相关  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency><!-- 基于AOP的Spring特性功能，如声明型事务管理  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency><!-- Spring EL, 表达式语言功能  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency><!-- 为Spring核心提供扩展  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- ============== spring core end ============== -->
		<!-- ============== web begin ============== -->
		<dependency><!-- Web应用开发时，用到Spring框架时所需的核心类  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency><!-- Spring MVC框架相关的所有类  -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- ============== web end ============== -->

    这些MyBatis框架所依赖的jar包处理完之后，我们下一步来看如何整合起来。

第二步：整合装配
    使用MyBatis来帮助数据处理，必然少不了对事务的管理，我们先来配置一下web.xml,让项目以在启动容器时，可以加载Spring容器，这段代码如下 
	<!-- Spring 配置文件 定义  -->
	<!-- 给ContextLoaderListener指定要加载的xml，无此配置将默认去加载/WEB-INF/下去加载 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:applicationContext.xml</param-value>
    </context-param>
    <!-- 配置ContextLoaderListener说明，该工程启动时将加载Spring容器，注意context-param配置的内容 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    然后我们去resource文件夹下创建applicationContext.xml文件，同时考虑到想解耦数据管理，顺带也创建一个名为jdbc.properties的文件，来存放数据方面的配置信息，jdbc.properties内容如下 
#MySQL驱动
jdbc.driver=com.mysql.jdbc.Driver
#数据连接URL
jdbc.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&serverTimezone=UTC&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456
#初始连接数
jdbc.initialSize=0
#定义最大连接数
jdbc.maxActive=20
#最大空闲
jdbc.maxIdle=20
#最小空闲
jdbc.minIdle=1
#最长等待时间
jdbc.maxWait=60000

    这里具体的用户名密码、链接地址要看自己的来配，但要注意一点，在使用连接mysql的jdbc驱动最新版时，会遇到数据库和系统时区差异引起的问题，这时候有两种解决方案，一种是降版本，这个我们知道就行了，适可而行，还有一种是在jdbc连接的url后面加上serverTimezone=UTC或GMT即可，如果需要使用gmt+8时区，需要写成GMT%2B8，否则可能会被解析为空。
    接下来看最重要的这块，就是applicationContext.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:p="http://www.springframework.org/schema/p" 
    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.3.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd 
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd 
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd ">

    <!-- 加载配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties" />
    </bean>
    <!-- ========================= ORM BEGIN  ========================= -->
    <!-- 数据源配置 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}" />
        <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>
        <!-- 连接池最大数量 -->
        <property name="maxActive" value="${jdbc.maxActive}"></property>
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="${jdbc.maxIdle}"></property>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="${jdbc.minIdle}"></property>
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="${jdbc.maxWait}"></property>
    </bean> 
    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件，mapperLocations的设置将会自动扫描MyBatis的xml文件-->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath*:test/demo/mapper/*Mapper.xml"/>  
    </bean>
    <!-- DAO接口所在包名，Spring会自动寻找其路径下的接口 -->  
    <bean id="demoDaoFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="test.demo.dao" />  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>  
    </bean>
    <!-- 数据事务管理 （ Spring允许允许 MyBatis参与到事务管理中，所以MyBatis没有特定的事务管理器，直接利用了Spring中的 DataSourceTransactionManager） -->  
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource"/>
    </bean> 
    <!-- ========================= ORM END  ========================= -->

</beans>

    来看内容，开头这段，说的是将数据相关的配置信息加载进来，接下来的先配置一个数据源，注意我们用的是com.alibaba.druid.pool.DruidDataSource，将使用德鲁伊的数据连接方式；接下来我们配置连接池sqlSessionFactory，同时指定数据源，这里边mapperLocations参数的设置，将使系统自动扫描与接口相匹配的mapper文件；然后配置demoDaoFactory，这个使用mybatis-spring提供了MapperScannerConfigurer类，避免一个个的去定义MapperFactoryBean，会自动去扫描指定路径下的所有接口，然后创建各自接口的动态代理类；最后还要说一下transactionManager的配置，由于Spring允许 MyBatis参与到事务管理中，所以MyBatis没有自己特定的事务管理器，直接利用了Spring中的 DataSourceTransactionManager。
    配置文件写好了，我们要写点代码配合测试下，看看效果怎么样。

第三步：测试代码
    首先，写一个用作数据传递的javaBean，User类，如下 
package test.demo.data;

public class User {
	private Integer id;
	private String 	name;
	private String 	password;
	private Integer age;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
}

    然后写接口，我们试着从数据库读一条数据吧，写接口，定义接口方法getUserById，给添加个条件，userId，代码如下 
package test.demo.dao;

import test.demo.data.User;

public interface UserDAO {
	public User getUserById(Integer userId);
}

    然后再回想下MyBatis的使用，我们还需要定义一个UserMapper.xml的文件，来添加对数据库操作的SQL内容，代码如下 
<?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="test.demo.dao.UserDAO">
	<select id="getUserById" parameterType="java.lang.Integer" resultType="test.demo.data.User">
		<![CDATA[
            select u.u_id id, u.u_name name, u.u_password password, u.u_age age from d_user u  WHERE u.u_id = #{userId}
        ]]>
	</select>
</mapper>

    这里要注意路径和命名规则，必须跟applicationContext.xml这个配置文件里的指定路径对应起来，否则会因为找不到相关文件服务器启动的时候报错。
    本来想写个单元测试直接试试，但这样的话只能展示出MyBatis对数据的处理是否成功，并不能跟上一篇的SpringMVC联系起来，于是直接修改下原来代码，在Controller添加了一个方法，修改后的代码如下 
package test.demo.controller;

import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import test.demo.dao.UserDAO;
import test.demo.data.User;

@Controller
public class TestSpringController {

	@Resource  
	private UserDAO userDao;
	
    @RequestMapping(value="/mvcIndex", method=RequestMethod.GET)
    public ModelAndView  mvcIndex() {
        return new ModelAndView("mvcIndex");
    }
    
    @ResponseBody
    @RequestMapping(value="/getHello", method=RequestMethod.GET)
    public String  getHello() {
        return "Hello Controller!";
    }
    
    @ResponseBody
    @RequestMapping(value="/getUser/{userId}", method=RequestMethod.GET)
    public String  getUser(@PathVariable Integer userId) {
    	User user = userDao.getUserById(userId);
        return user.getName() + " , Hello Controller!";
    }
}

    这里要注意@Resource的使用，这时候代码部分差不多已经完事儿了，整个项目结构基本是下图的样子，接下来我们可以尝试着打包部署，然后测试。


    构建的时，我这里遇到一个问题，就是UserMapper.xml文件并不能够听话的被写进war文件，这个很恼火，原因是maven在构建打包的时候，全然不考虑文件路径中.xml结尾的文件，我们得去pom文件的build元素下，添加这样一段代码，如下 
	<resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>
             <resource>  
                <directory>src/main/resources</directory>  
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

    这段代码的意思很显然是解决这个问题的，接着再构建，一切就OK了，然后我们愉快的打包部署，可以测试了。

第四步：运行结果
    服务器启动之后，我们在浏览器输入：http://localhost:8080/demo/getUser/1，回车
   

    然后把1改成2：http://localhost:8080/demo/getUser/2，回车
   

    看到这些内容，好了，我们已经成功的将MyBatis引入系统。




  • 大小: 2.8 KB
  • 大小: 26.5 KB
  • 大小: 4.1 KB
  • 大小: 4.2 KB
分享到：
| Spring回顾之二 —— 引入SpringMVC
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics