Spring与Mabatis整合案例---XML/纯注解

需要导入的包

环境搭建

pojo类

package com.ywq.ssm.pojo;

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;
	}
	public User(Integer id, String name, String password, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.password = password;
		this.age = age;
	}
	public User() {
		super();
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", password=" + password + ", age=" + age + "]";
	}
	
	
}

mapper接口

package com.ywq.ssm.mapper;

import com.ywq.ssm.pojo.User;

public interface UserMapper {
	
	int insert(User user);
	
	User selectByPrimaryKey(Integer id);
	
}

mapper.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="com.ywq.ssm.mapper.UserMapper">

	<insert id="insert" parameterType="User" keyColumn="id"
		keyProperty="id" useGeneratedKeys="true">
		insert into user (name,password,age) values(#{name},#{password},#{age})

	</insert>

	<select id="selectByPrimaryKey" parameterType="Integer"
		resultType="User">
		select * from user where id = #{id}
	</select>

</mapper>

Service接口

package com.ywq.ssm.service;

import com.ywq.ssm.pojo.User;

public interface UserService {
	int insert(User user);
	
	User selectByPrimaryKey(Integer id);
}

Service实现类

package com.ywq.ssm.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ywq.ssm.mapper.UserMapper;
import com.ywq.ssm.pojo.User;
import com.ywq.ssm.service.UserService;

@Service
public class UserServiceImpl  implements UserService{
	
	
	/*
	 * 问题：UserMapper映射接口的代理对象如何创建？
	 * 
	 * 
	 * 一，使用Spring之前
	 * 1.读取mybatis-config.mxl主配置文件，创建SqlSessionFactory工厂对象
	 * 
	 * 2.使用工厂对象创建SqlSession 会话对象
	 * 
	 * 3.使用SqlSession的getMapper方法创建映射接口代理对象
	 * 	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	 * 
	 * 4.提交事务
	 * 
	 * 5.关闭SqlSession
	 * 所有步骤全部开发者自己编写代码完成
	 * 
	 * 二，和Spring集成，全部操作交给Spring管理
	 * 
	 * MyBatis框架已经和Spring集成好了，在MyBatis和Spring集成的桥梁包中
	 * 	mybatis-spring-1.3.1.jar,开发者只需要将创建代码配置到Spring即可
	 * 
	 * 
	 * 1.Spring帮忙创建SqlSessionFactory对象
	 * MyBatis框架已经和Spring集成好了，而且编写好了创建SqlSessionFacoty对象的代码
	 * 桥梁包：org.mybatis.spring.SqlSessionFactoryBean
	 * 
	 * 
	 * 2.和Spring集成不用创建SqlSession对象，每次创建映射接口代理对象会自动底层先创建
	 * 		SqlSession，再创建映射接口的代理对象
	 * 
	 * 3，创建映射接口的代理对象
	 * 	3.1创建单个映射接口代理对象
	 * 	桥梁包：org.mybatis.spring.mapper.MapperFactoryBean<T>
	 * 
	 *	3.2使用包扫面创建包下面所有的映射接口代理对象（推荐）
	 * 	桥梁包：org.mybatis.spring.mapper.MapperScannerConfigurer
	 * */
	
	@Autowired
	private UserMapper UserMapper;
	
	@Override
	public int insert(User user) {
		
		return UserMapper.insert(user);
	}

	@Override
	public User selectByPrimaryKey(Integer id) {
		
		return UserMapper.selectByPrimaryKey(id);
	}

}

db.properties文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
jdbc.maxActive=20

log4j.properties文件

# Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
# 配置日志
# 规则 log4j.logger.映射接口的包=日志级别
# 总共五个级别（error:错误,info：普通信息,debug：调试信息,warn：警告,trae/all：所有情况）
# 当前开发阶段配置debug/ (all/trace),项目上线以后配置error
log4j.logger.com.ywq.ssm.mapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

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:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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">

	<!-- 配置包扫描位置 -->
	<context:component-scan base-package="com.ywq.ssm"/>
	
	<!-- 读取数据库配置文件 -->
	<context:property-placeholder location="classpath:db.properties"/>
	
	<!-- 配置阿里巴巴连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
		<property name="maxActive" value="${jdbc.maxActive}"/>
	</bean>
	
	<!-- 配置SqlSessionFactoryBean -->
	<bean id="sqlSessionFactor" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 配置数据源 -->
		<property name="dataSource" ref="dataSource"/>
		
		<!-- 读取映射接口对应的映射文件 【可选】，底层自动绑定接口映射文件，理论上可以不用配-->
		<property name="mapperLocations">
			<array>
			<!-- 读取单个映射文件 -->
				<!-- <value>classpath:com/ywq/ssm/mapper/UserMapper.xml</value> -->
				
				<!-- 读取所有映射文件：* 通配符 -->
				<value>classpath:com/ywq/ssm/mapper/*Mapper.xml</value>
			</array>
		</property>
		
		<!-- 使用包扫描配置pojo别名 -->
		<property name="typeAliasesPackage" value="com.ywq.ssm.pojo"/>
		
		<!-- 读取配置Mybatis默认的主配置文件 -->
		<property name="configLocation" value="classpath:mybatis-config.xml"></property>
	</bean>
	
	
	<!-- 创建单个映射接口对象 -->
<!-- 	<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
		配置映射接口
		<property name="mapperInterface" value="com.ywq.ssm.mapper.UserMapper"/>
		
		配置SqlSessionFactory工厂对象
		<property name="sqlSessionFactory" ref="sqlSessionFactor"/>
		
	</bean> -->
	
	
	
	<!-- 使用包扫描创建所有映射接口的代理对象
		此配置创建的多个bean，所以不用id/name接收
		
	 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- MyBatis映射接口的包 -->	
		<property name="basePackage" value="com.ywq.ssm.mapper"></property>
		
		<!-- 配置SqlSessionfactory工厂bean的名称【可选】 -->
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactor"></property>
	
	</bean>
	
	
	
	<!-- 
		1.配置事务管理器
		2.配置事务通知
		3.使用AOP将事务通知切入到Servic层
	
	 -->
	 
	 <!-- 1.配置事务管理器 -->
	 <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	 	<!--配置数据源  -->
	 	<property name="dataSource" ref="dataSource"/>
	 </bean>
	
	<!-- 2.配置事务通知/增强 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<!-- DQL -->
			<tx:method name="select*" read-only="false"/>
			<!--DML  -->
			<tx:method name="*"/>
		</tx:attributes>
	</tx:advice>
	<!-- 3.使用AOP将事务通知切入到Service层 -->
	<aop:config>
		<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.ywq.ssm.service..*.*(..))"/>	
	</aop:config>
		
	
</beans>

纯注解配置代码

package com.ywq.ssm;

import javax.sql.DataSource;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.Scope;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.alibaba.druid.pool.DruidDataSource;

/*
 * @Configuration
 * 把当前类作为Spring配置类，所有Spring的全局配置都在此类中配置，相当于applicationContext.xml
 * 
 * @ComponentScan
 * 配置Springz支持注解配置的包扫描位置
 * 
 * @Bean 把当前方法作为配置方法，Spring框架启动，自动执行此方法，并将方法返回结果放入到Spring容器中
 * 	属性说明
 * 		name="配置bean的id/name"
 * 		initMethod="初始化执行方法"
 * 		destroyMethod="销毁执行方法"
 * 
 * @Scope 配置bean的作用范围
 * 
 * @PropertySource 读取xx.properties配置文件
 * @PropertySource("classpath:db.properties")
 * 
 * */

@Configuration
@ComponentScan("com.ywq.ssm")
@PropertySource("classpath:db.properties")
@EnableTransactionManagement // 支持Spring事务注解配置驱动
@MapperScan("com.ywq.ssm.mapper")//使用包扫描创建映射接口的代理对象
public class SpringConfig {

	/*
	 * @Value 读取db.properties配置文件的key对应的值，将值赋值到变量
	 * 
	 * @Value("${xxx.properties配置文件的key}")
	 * 
	 * 如果不想读取配置文件的内容 可以可以自定义写死某一个值
	 * 
	 * @Value("123")
	 * 
	 */
	@Value("${jdbc.driverClassName}")
	private String driverClassName;

	@Value("${jdbc.url}")
	private String url;

	@Value("${jdbc.username}")
	private String username;

	@Value("${jdbc.password}")
	private String password;

	@Value("${jdbc.maxActive}")
	private Integer maxActive;

	@Bean(name = "dataSource", initMethod = "init", destroyMethod = "close")
	@Scope("singleton")
	public DataSource getDataSource() {
		System.out.println("连接池已创建。。");
		DruidDataSource ds = new DruidDataSource();
		ds.setDriverClassName(driverClassName);
		ds.setUrl(url);
		ds.setUsername(username);
		ds.setPassword(password);
		ds.setMaxActive(maxActive);
		return ds;
	}

	
	/*
	 * 创建MyBatis的工厂对象：SqlSessionFactory
	 * */
	@Bean
	public SqlSessionFactoryBean getFactory() throws Exception {
		System.out.println("SqlSessionFactory创建了..");
		SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
		
		// 设置数据源
		sqlSessionFactoryBean.setDataSource(getDataSource());
		
		// 配置别名
		sqlSessionFactoryBean.setTypeAliasesPackage("com.ywq.ssm.pojo");
		
		SqlSessionFactory object = sqlSessionFactoryBean.getObject();
		return sqlSessionFactoryBean;
	}

	// 配置事务管理器
	@Bean
	public PlatformTransactionManager getTxManager() {

		return new DataSourceTransactionManager(getDataSource());

	}

}

测试代码

package com.ywq.ssm.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.ywq.ssm.SpringConfig;
import com.ywq.ssm.pojo.User;
import com.ywq.ssm.service.UserService;


@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = SpringConfig.class)
public class UserServiceTest {
	@Autowired
	private UserService userService;
	
	@Test
	public void testInsert() {
		User user = new User(null, "李兵", "152", 22);
		int row = userService.insert(user);
		System.out.println(row);
	}

	@Test
	public void testSelectByPrimaryKey() {
		User user = userService.selectByPrimaryKey(12);
		System.out.println("user:"+user);
	}

}