阶梯式使用SpringMVC+MyBatis

概述

对于SpringMVC的使用，上一篇文章已经做了说明,并上传了Demo，大家可以下载下来练习指教。这篇文章将由浅入深的集成MyBatis，并给出可以运行的Code。

MyBatis基础条件

下载MyBatis开发包，将其核心包和lib下所有包拷贝到项目lib目录，这些包在之后都会用到，同时添加到classpath下。下载地址为：http://code.google.com/p/mybatis/。

在ClassPath(src目录）下添加MyBatis基础配置文件，名称可自定义，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	
	<!--声明数据库方言为Mysql-->
	<properties>    
    	<property name="dialect" value="mysql"/>
    </properties>
	<settings>
		<!-- 这个配置使全局的映射器启用或禁用缓存 -->
		<setting name="cacheEnabled" value="true"/>
		<!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载 -->
		<setting name="lazyLoadingEnabled" value="true"/>
		<!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载 -->
		<setting name="aggressiveLazyLoading" value="false"/>
		<!-- 允许或不允许多种结果集从一个单独的语句中返回（需要适合的驱动） -->
		<setting name="multipleResultSetsEnabled" value="true"/>
		<!-- 使用列标签代替列名。不同的驱动在这方便表现不同。参考驱动文档或充分测试两种方法来决定所使用的驱动 -->
		<setting name="useColumnLabel" value="true"/>
		<!-- 允许JDBC支持生成的键。需要适合的驱动。如果设置为true则这个设置强制生成的键被使用，尽管一些驱动拒绝兼容但仍然有效（比如Derby） -->
		<setting name="useGeneratedKeys" value="true"/>
		<!-- 指定MyBatis如何自动映射列到字段/属性。PARTIAL只会自动映射简单，没有嵌套的结果。FULL会自动映射任意复杂的结果（嵌套的或其他情况） -->
		<setting name="autoMappingBehavior" value="FULL"/>
		<!-- 配置默认的执行器。SIMPLE执行器没有什么特别之处。REUSE执行器重用预处理语句。BATCH执行器重用语句和批量更新 -->
		<setting name="defaultExecutorType" value="SIMPLE"/>
		<!-- 设置超时时间，它决定驱动等待一个数据库响应的时间 -->
		<setting name="defaultStatementTimeout" value="25000"/>
	</settings>
	<!--为实体类指定别名-->
	<typeAliases>
        <typeAlias type="entity.Archives" alias="archive"/>
        <typeAlias type="entity.Student" alias="student"/>
        <typeAlias type="entity.Teacher" alias="teacher"/>
        <typeAlias type="entity.School" alias="school"/>
    </typeAliases>
	<!--分页会用到-->
    <plugins>
    	<plugin interceptor="Interceptor.PaginationInterceptor"></plugin>
    </plugins>
</configuration>

配置数据源

本文在tomcat中配置数据源,并通过Spring的Jndi方式lookup数据源，步骤如下：找到tomcat安装目录下conf目录，打开server.xml，在host节点中加入如下内容：

  <Context docBase="SpringMVC" path="/SpringMVC" reloadable="false" source="org.eclipse.jst.jee.server:SpringMVC">
      	<Resource name="jdbc/spring"
	       auth="Container"
	       type="javax.sql.DataSource"
	       driverClassName="com.mysql.jdbc.Driver"
	       url="jdbc:mysql://localhost:3306/springmvc"
	       username="root"
	       password="root"
	       maxActive="100"
	       maxIdle="30"
	       maxWait="10000" />
  </Context>

上述配置文件中只要注意Resource中name为jndi名称，spring将通过该名称查找数据源。其配置如下:

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
		<property name="jndiName">
			 <value>java:comp/env/jdbc/spring</value>
		</property>
</bean>

创建实体类

实体类为普通的pojo对象，不再详细描述。本例中包括:Archives.java,Student.java,School.java,Teacher.java,

关系为

student----1------------- 1--------Archives,

School----1---------------n--------Teacher,

Teacher--1---------------n--------Student。

创建Mapper文件

Mapper文件是实体类和数据库表的映射文件，并且sql语句也在该文件中维护，不是散落在系统中，方便以后的改变。本Demo创建了四个mapper文件分别为：Archives.xml（档案）,School.xml（学校）,Student.xml（学生），Teacher.xml（教师），将它们放到mapper包下，内容如下：

<?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="ArchivesMapper">
    <select id="getArchiveById" resultType="archive">
        <![CDATA[
            select * from archives where id=#{id}
        ]]>
    </select>
    
    <select id="getAllArchive" resultType="list" resultMap="archiveResultMap">
        <![CDATA[
            select * from archives
        ]]>
    </select>
    
    <!-- accountMap.accountResultMap是account-resultmap.xml中定义的resultmap，通过namespace.id找到 -->
    <select id="getArchiveByNames" parameterType="string" resultMap="archiveResultMap">
        <![CDATA[
            select * from account where username = #{name}
        ]]>
    </select>
    
    <sql id="user_name_pwd">
        username, password
    </sql>
    
    <!-- 自动生成id策略 -->
    <insert id="addArchive" parameterType="archive">
        insert into archives(id, name)
        values(#{id}, #{name})
    </insert>
    
    <!-- 根据selectKey语句生成主键 -->
    <!-- <insert id="addAccount4Key" parameterType="account">
        <selectKey keyProperty="account_id" order="BEFORE" resultType="int">
            select cast(random() * 10000 as Integer) a from #Tab
        </selectKey>
        insert into account(account_id, status, username, password)
        values(#{accountId}, #{status}, #{username}, #{password})
    </insert>
     -->
    
    <update id="editAccount" parameterType="archive">
        update archives set
        name = #{name}
        where id = #{id}
    </update>
    
    <delete id="removeArchive" parameterType="int">
        delete from archives where id = #{id}
    </delete>
    
    
    <resultMap type="entity.Archives" id="archiveResultMap">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
    </resultMap>
    
    
</mapper>

其它不再列举,对于其映射原理大家可以参看官网,本文后面会有一个查询举例。

配置SqlSessionFactory

在spring配置文件applicationContext.xml中集成MyBatis的配置文件mybatis-config.xml,同时指定数据源,并引入MyBatis的mapper文件，配置如下：

<!-- 创建SqlSessionFactory，同时指定数据源 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:mybatis-config.xml" />
		<property name="dataSource" ref="dataSource" />
		<property name="mapperLocations">
			<list>
				<value>classpath:mapper/*.xml</value>
			</list>
		</property>
	</bean>

配置事务

本文采用spring的注解方式声明事务,这里需要注意需要开启注解驱动,并且不要重复扫描,否则事务会失效。所谓重复扫描，当开始扫描组件后,应该剔除掉曾经扫描过的注解。如下：

开启注解驱动

<mvc:annotation-driven/>

开启扫描组件,并剔除不需要重复扫描的注解

 <context:component-scan>
    	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />
    </context:component-scan>

或者指定base-package,如下：

 <context:component-scan base-package="service">
    </context:component-scan>

指定jdbc事务

<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

此后就可以在代码中通过@Transactional来声明类或者方法使用事务。

Dao层

使用MyBatis通用dao,SqlSessionDaoSupport其需要引入如下包：mybatis-spring-1.1.1-SNAPSHOT.jar,去其官网下载mybatis-spring-1.2.0-bundle.zip 。自定义一个类CommonDao集成SqlSessionDaoSupport。内容如下：

package dao;

import java.io.Serializable;
import java.util.List;

import javax.annotation.Resource;

import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.stereotype.Repository;

@Repository
public class CommonDao extends SqlSessionDaoSupport {
	
	@Resource(name="sqlSessionFactory")
	private SqlSessionFactory sqlSessionFactory;

	public void save(String key, Object object){
		this.getSqlSession().insert(key, object);
	}
	
	
	public void delete(String key, Serializable id){
		this.getSqlSession().delete(key, id);
	}
	
	public void delete(String key, Object object){
		this.getSqlSession().delete(key, object);
	}
	
	public <T> T get(String key, Object paramObject){
		return this.getSqlSession().selectOne(key, paramObject);
	}
	
	public <T> List<T> getList(String key){
		return this.getSqlSession().selectList(key);
	}
	
	public <T> List<T> getList(String key, Object paramObject){
		return this.getSqlSession().selectList(key, paramObject);
	}
	
	public <T> List<T> getPageList(String key, Object paramObject, int offset, int limit){
		return this.getSqlSession().selectList(key, paramObject,new RowBounds(offset,limit));
	}
	
}

声明了常见的增删改查语句,需要注意的是key为实体mapper文件中的namespace+.+具体的语句id。

Service层
目前只有一个service，实际开发应该一类业务对应一个service，采用注解的方式托管给spring,其内容如下:

package service;

import java.util.List;

import javax.annotation.Resource;


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

import dao.CommonDao;

import entity.Archives;
import entity.School;
import entity.Student;
import entity.Teacher;

@Service
public class MenuService {

	@Resource(name="commonDao")
	private CommonDao commonDao;
	
	public List<Student> find() {
		
		return null;
	}

	public void delete(int id) {
		
		commonDao.delete("ArchivesMapper.removeArchive", 1);
	}

	@Transactional
	public void savaArchive(Archives archive) {
		
		commonDao.save("ArchivesMapper.addArchive", archive);
	}
	
	
	@Transactional
	public void savaStudent(Student student) {
		
		commonDao.save("StudentMapper.addStudent", student);
	}

	public Student findStu(int id) {
		
		return commonDao.get("StudentMapper.getStudentById", id);
	}

	
	    /**  
	     * 此方法描述的是：  保存学生信息	     

	     * @author: liubo  
	     * @version: 2013-4-7 下午02:26:18  
	     */  
	    
	public void saveSchool(School sch) {
		
		commonDao.save("SchoolMapper.addSchool", sch);
	}

		
		    /**  
		     * 此方法描述的是：根据id查找学校信息  
		     * @author: liubo  
		     * @version: 2013-4-7 下午02:28:05  
		     */  
		    
	public School findSch(int id) {
		
		
		
		return commonDao.get("SchoolMapper.getSchoolById", id);
	}

			
			    /**  
			     * 此方法描述的是：保存教师信息  
			     * @author: liubo  
			     * @version: 2013-4-7 下午02:37:32  
			     */  
			    
	public void saveTeacher(Teacher tea) {
		
		commonDao.save("TeacherMapper.addTeacher", tea);
		
	}

				
				    /**  
				     * 此方法描述的是：根据id查找教师信息  
				     * @author: liubo  
				     * @version: 2013-4-7 下午02:38:21  
				     */  
				    
	public Teacher findTea(int id) {
		// TODO Auto-generated method stub
		return commonDao.get("TeacherMapper.getTeacherById", id);
	}

					
	    /**  
	     * 此方法描述的是： 分页查找学校信息 
	     * @author: liubo  
	     * @version: 2013-4-8 下午02:14:39  
	     */  
	    
	public List<School> findSchList(int offset, int limit) {
		
		
		return commonDao.getPageList("SchoolMapper.getAllSchool", null, offset, limit);
	}

		
	    /**  
	     * 此方法描述的是： 分页查找学生信息 
	     * @author: liubo  
	     * @version: 2013-4-8 下午02:38:04  
	     */  
	    
	public List<Student> findStuList(int offset, int limit) {
		
		return commonDao.getPageList("StudentMapper.getAllStudent", null, offset, limit);
	}
	
	
			

}

控制层

采用SpringMVC作为控制器，主要针对查询做了测试,内容如下:

/** 
 * 
 * @author geloin 
 * @date 2012-5-5 上午9:31:52 
 */
package snippet;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import service.MenuService;

import entity.Archives;
import entity.School;
import entity.Student;
import entity.Teacher;


/**
 * 
 * @author geloin
 * @date 2012-5-5 上午9:31:52
 */
@Controller
public class LoginController {

	//注入service
	@Resource(name="menuService")
	private MenuService menuService;

	//映射url请求路径

	@RequestMapping("/to_login")
	public ModelAndView toLogin() throws Exception {

		Map<String, Object> map = new HashMap<String, Object>();

//		List<Student> result = this.menuService.find();
		//分页查询		

		List<Student> result = this.menuService.findStuList(0,2);
		
		for(Student stu : result){
			System.out.println(stu.getId()+"---"+stu.getArchive());
		}

//		System.out.println(menuService);
//		map.put("result", result);
//
//		return new ModelAndView("menu", map);
		return null;
	}
	
	
	@RequestMapping("/insert")
	public ModelAndView insert() throws Exception {
		
		Archives archive = new Archives();
		archive.setName("archive");
		try{
		menuService.savaArchive(archive);
		}catch(Exception e){
			e.printStackTrace();
		}
		return null;
	}
	
	
	@RequestMapping("/insertStu")
	public ModelAndView insertStu() throws Exception {
		Student stu = new Student();
		stu.setName("stu");
		Archives archive = new Archives();
		archive.setId(1);
		stu.setArchive(archive);
		try{
		menuService.savaStudent(stu);
		}catch(Exception e){
			e.printStackTrace();
		}
		return null;
	}
	
	@RequestMapping("/selectStu")
	public ModelAndView selectStu() throws Exception {
		Student stu = menuService.findStu(1);
		System.out.print(stu.getArchive().getName());
		return null;
	}
	
	
	@RequestMapping("/insertSch")
	public ModelAndView insertSch() throws Exception {
		School sch = new School();
		sch.setName("sch");
		try{
		menuService.saveSchool(sch);
		}catch(Exception e){
			e.printStackTrace();
		}
		return null;
	}
	
	@RequestMapping("/selectSch")
	public ModelAndView selectSch() throws Exception {
		List<School> schList = menuService.findSchList(2,5);
		for(School sch : schList){
			System.out.println(sch.getId());
			System.out.println("--------------------------------");
		}
//		List<Teacher> tList = sch.gettList();
		return null;
	}
	
	@RequestMapping("/insertTea")
	public ModelAndView insertTea() throws Exception {
		Teacher tea = new Teacher();
		tea.setName("tea");
		School sch = new School();
		sch.setId(1);
		tea.setSchool(sch);
		try{
		menuService.saveTeacher(tea);
		}catch(Exception e){
			e.printStackTrace();
		}
		return null;
	}
	
	@RequestMapping("/selectTea")
	public ModelAndView selectTea() throws Exception {
		Teacher tea = menuService.findTea(1);
		List<Student> tList = tea.getsList();
		return null;
	}
	
}

一对一关联查询

可以懒加载

一对多关联查询

可以懒加载

MyBatis缓存

使用ehcache来做为缓存组件，需要下载mybatis-ehcache-1.0.1-bundle.zip,并将包加入classpath。需要配置文件。

懒加载

通过配置实现

以上内容已经测试通过,下次补上。。。