Mybatis学习笔记之二（动态mapper开发和spring-mybatis整合）

一、输入映射和输出映射

1.1 parameterType(输入类型)

【传递简单类型】

详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）

使用#{}占位符，或者${}进行sql拼接。

【传递pojo对象】

详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）

Mybatis使用ognl表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称。

1.2 传递pojo包装对象

　　开发中通过可以使用pojo传递查询条件。查询条件可能是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如查询用户信息的时候，将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

　　包装对象：Pojo类中的一个属性是另外一个pojo。

　　需求：根据用户名模糊查询用户信息，查询条件放到QueryVo的user属性中。

【编写QueryVo类】

package com.kevin.entity;

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

import com.kevin.entity.User;

public class QueryVo implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    private User user;
    
    public void setUser(User user) {
        this.user = user;
    }
}

【Mapper.xml文件】

在UserMapper.xml中配置sql，如下：

    <!-- 根据QueryVo查询 -->
    <select id="findUserByQueryVo" parameterType="QueryVo" resultType="User">
        select * from User where username like "%"#{user.username}"%"
    </select>

【Mapper接口】

在UserMapper接口中添加方法，如下：

    /*
     * 使用QueryVo根据用户名称模糊查询
     */
    public List<User> findUserByQueryVo(QueryVo vo);

【测试方法】

在UserMapeprTest增加测试方法，如下：

    /*
     * 使用QueryVo根据用户名称模糊查询
     */
    @Test
    public void findUserByQueryVo() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("王");
        vo.setUser(user);
        
        List<User> list = userMapper.findUserByQueryVo(vo);
        for (User user2 : list) {
            System.out.println(user2);
        }
    }

1.3 resultType(输出类型)

1.3.1 输出简单类型

需求:查询用户表数据条数

【Mapper.xml文件】

在UserMapper.xml中配置sql，如下：

    <!-- 查询数据条数 -->
    <select id="countUser" resultType="Integer">
        select count(*) from User
    </select>

【Mapper接口】

在UserMapper添加方法，如下：

/*
     * 查询数据条数
     */
    public Integer countUser();

【 测试方法】

/*
     * 查询数据条数
     */
    @Test
    public void countUser() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        
        Integer count = userMapper.countUser();
        System.out.println(count);

    }

Tips：输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。

1.3.2 输出pojo对象

详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）

1.3.3 输出pojo列表

详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）

1.4 resultMap

　　resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系 ，resultMap实质上还需要将查询结果映射到pojo对象中。resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

需求：查询订单表order的所有数据

【声明pojo对象】

package com.kevin.entity;

import java.io.Serializable;
import java.util.Date;

public class Orders  implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private Integer id;

    private Integer userId;

    private String number;

    private Date createtime;

    private String note;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number == null ? null : number.trim();
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note == null ? null : note.trim();
    }

    @Override
    public String toString() {
        return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
                + ", note=" + note + "]";
    }

    
    
}

【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.kevin.mapper.OrdersMapper">
    <!-- 查询所有数据 -->
    <select id="findAll" resultType="Orders">    
        select * from Orders
    </select>

</mapper>

【Mapper接口】

package com.kevin.mapper;

import java.util.List;

import com.kevin.entity.Orders;

public interface OrdersMapper {
    
    /*
     * 查询所有数据（类属性与数据库字段不一致）
     */
    public List<Orders> findAll();

}

【测试方法】

    /*
     *查询所有数据（属性名称与数据库字段名称不一致） 
     */
    @Test
    public void findAll() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        OrdersMapper mapper = sqlSession.getMapper(OrdersMapper.class);
        
        List<Orders> list = mapper.findAll();
        for (Orders order : list) {
            System.out.println(order);
        }

    }

1.4.1 使用resultMap

　　由于上边的mapper.xml中sql查询列(user_id)和Order类属性(userId)不一致，所以查询结果不能映射到pojo中。需要定义resultMap，把orderResultMap将sql查询列(user_id)和Order类属性(userId)对应起来

改造OrderMapper.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.kevin.mapper.OrdersMapper">
    <resultMap type="Orders" id="orders">
        <result column="user_id" property="userId"/>
    </resultMap>
    <!-- 查询所有数据 -->
    <!-- <select id="findAll" resultType="Orders"> -->
    <select id="findAll" resultMap="orders">
        select * from Orders
    </select>

</mapper>

二、动态sql拼接

　　通过mybatis提供的各种标签方法实现动态拼接sql。

　　需求：根据性别和名字查询用户

2.1 使用If标签和WHERE标签

【Mapper.xml文件】

<!-- 多条件查询 where标签可以去掉前面第一个and -->
    <select id="findUserBySexAndUsername" parameterType="User" resultType="User">
       select * from User 
        <where>
            <if test="sex != null and sex != ''">
                sex = #{sex}
            </if>
            <if test="username != null">
                and username = #{username}
            </if>
        </where>
    </select>

【Mapper接口】

编写Mapper接口，如下：

    /*
     * 多条件查询
     */
    public List<User> findUserBySexAndUsername(User user);

【测试方法】

在UserMapperTest添加测试方法，如下：

/*
     * 多条件查询
     */
    @Test
    public void findUserBySexAndUsername() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        
        User user = new User();
        user.setUsername("Kevin");
        user.setSex("Male");
        
        List<User> list = mapper.findUserBySexAndUsername(user);
        for (User u: list) {
            System.out.println(u);
        }

    }

2.2 Sql片段

　　Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的。

　　把上面例子中的select * from User 提取出来，作为sql片段，如下：

　　<!-- 提取SQL语句中重复片段 -->
　　<sql id="selector">
　　　　select * from User 
　　</sql>

　　 <!-- 多条件查询 where标签可以去掉前面第一个and -->
    <select id="findUserBySexAndUsername" parameterType="User" resultType="User">
        <include refid="selector"></include>
        <where>
            <if test="sex != null and sex != ''">
                sex = #{sex}
            </if>
            <if test="username != null">
                and username = #{username}
            </if>
        </where>
    </select>

2.3 foreach标签

需求：根据多个id查询用户信息

【改造QueryVo】

如下面在pojo中定义list属性ids存储多个用户id，并添加setter方法

package com.kevin.entity;

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

import com.kevin.entity.User;

public class QueryVo implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    private User user;
    
    private List<Integer> list;
    
    public void setList(List<Integer> list) {
        this.list = list;
    }


    public void setUser(User user) {
        this.user = user;
    }
    

}

【Mapper.xml文件】

UserMapper.xml添加sql，如下：

    <!--  根据多个id查询 -->
    <select id="findUserByIds" parameterType="QueryVo" resultType="User">
        <include refid="selector"></include>
        where id in
        <foreach collection="list" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </select> 

【测试方法】

    /*
     *根据多个id查询
     */
    @Test
    public void findUserByIds() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        
        /*
         * 使用QueryVo中的List列表
         */
        List<Integer> lists = new ArrayList<Integer>();
        lists.add(28);
        lists.add(29);
        lists.add(25);
        lists.add(30);
        QueryVo vo = new QueryVo();
        vo.setList(lists);

        List<User> list = mapper.findUserByIds(lists);
        for (User u: list) {
            System.out.println(u);
        }
    }

 

三、关联查询

3.1  一对一查询

需求：查询所有订单信息，关联查询下单用户信息。

注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。

方法一：使用resultType

　　使用resultType，改造订单pojo类，此pojo类中包括了订单信息和用户信息，这样返回对象的时候，mybatis自动把用户信息也注入进来了。

【改造pojo类】

　　OrderUser类继承Order类后OrderUser类包括了Order类的所有字段，只需要定义用户的信息字段即可，如下图：

 

【Mapper.xml】

在UserMapper.xml添加sql，如下

<!-- 查询订单，同时包含用户数据 -->

<select id="queryOrderUser" resultType="orderUser">
SELECT
o.id,
o.user_id
userId,
o.number,
o.createtime,
o.note,
u.username,
u.address
FROM
`order` o
LEFT JOIN `user` u ON o.user_id = u.id
</select>

【Mapper接口】

在UserMapper接口添加方法，如下图：

 

【测试方法】

在UserMapperTest添加测试方法，如下：

@Test

public void testQueryOrderUser() {
// mybatis和spring整合，整合之后，交给spring管理
SqlSession sqlSession = this.sqlSessionFactory.openSession();
// 创建Mapper接口的动态代理对象，整合之后，交给spring管理
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 使用userMapper执行根据条件查询用户
List<OrderUser> list = userMapper.queryOrderUser();
for (OrderUser ou : list) {
System.out.println(ou);
}
// mybatis和spring整合，整合之后，交给spring管理

sqlSession.close();
}

【小结】

　　定义专门的pojo类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单，企业中使用普遍。

方法二：使用resultMap

　　使用resultMap，定义专门的resultMap用于映射一对一查询结果。

【改造pojo类】

　　在Order类中加入User属性，user属性中用于存储关联查询的用户信息，因为订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息。

　　改造Order如下：

package com.kevin.entity;

import java.io.Serializable;
import java.util.Date;

public class Orders  implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private Integer id;
    private Integer userId;
    private String number;
    private Date createtime;
    private String note; 
    private User user;
    public void setUser(User user) {
        this.user = user;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number == null ? null : number.trim();
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note == null ? null : note.trim();
    }

    @Override
    public String toString() {
        return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
                + ", note=" + note + "]";
    }

    
    
}

【Mapper.xml】

    
    <!-- 一对一关联查询 -->
    <resultMap type="Orders" id="order">
        <result column="id" property="id"/>
        <result column="user_id" property="userId"/>
        <result column="number" property="number"/>
        <result column="createtime" property="createtime"/>
        <!-- 一对一 -->
        <association property="user" javaType="User">
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
        </association>
    </resultMap>
    <select id="selectOrders" resultMap="order">
        select
        o.id,
        o.user_id,
        o.number,
        o.createtime,
        u.username
        from orders o
        left join user u
        on o.user_id = u.id
    </select>

【Mapper接口】

    /*
     * 一对一关联查询，以订单为中心关联用户
     */
    public List<Orders> selectOrders();

【测试方法】

在UserMapperTest增加测试方法，如下：

    
    /*
     * 一对一查询
     */
    @Test
    public void selectOrders() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrdersMapper mapper = sqlSession.getMapper(OrdersMapper.class);
        
        List<Orders> selectOrders = mapper.selectOrders();
        for (Orders orders : selectOrders) {
            System.out.println(orders);
        }        
    }

3.2  一对多查询

　　案例：查询所有用户信息及用户关联的订单信息。用户信息和订单信息为一对多关系。

【修改pojo类】

在User类中加入List<Orders> ordersList属性,如下：

package com.kevin.entity;

import java.util.Date;
import java.util.List;

public class User {
    /**
     * 创建一个简单的bean
     */
    private static final long serialVersionUID = 1L;
    private Integer id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
    
    private List<Orders> ordersList;
    


    public List<Orders> getOrdersList() {
        return ordersList;
    }
    public void setOrdersList(List<Orders> ordersList) {
        this.ordersList = ordersList;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + ", birthday=" + birthday + ", address=" + address + "]";
    }


}

【Mapper.xml】

<!-- /*
     * 一对多关联
     */
    public List<User> selectUsersList(); -->
    <resultMap type="User" id="user">
        <id column="user_id" property="id"/>
        <result column="username" property="username"/>
        <!-- 一对多 -->
        <collection property="ordersList" ofType="Orders">
            <id column="id" property="id"/>
            <result column="number" property="number"/>
        </collection>
    </resultMap>
    <select id="selectUserList" resultMap="user">
        select
        o.id,
        o.user_id,
        o.number,
        o.createtime,
        u.username
        from user u
        left join orders o
        on o.user_id = u.id
    </select>

【Mapper接口】

编写UserMapper接口，如下：

　　　/*
     * 一对多关联
     */

　　　　public List<User> selectUserList();

【测试方法】

/*
     * 一对多关联
     */
    @Test
    public void selectUsersList() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrdersMapper mapper = sqlSession.getMapper(OrdersMapper.class);
        
        List<User> selectUsersList = mapper.selectUserList();
        for (User user : selectUsersList) {
            System.out.println(user);
        }
    }

四、Mybatis整合spring

4.1 整合思路

　　● SqlSessionFactory对象应该放到spring容器中作为单例存在。

　　● 传统dao的开发方式中，应该从spring容器中获得sqlsession对象。

　　● Mapper代理形式中，应该从spring容器中直接获得mapper的代理对象。

　　● 数据库的连接以及数据库连接池事务管理都交给spring容器来完成。

4.2 整合需要的jar包

　　● spring的jar包

　　● Mybatis的jar包

　　● Spring+mybatis的整合包。

　　● Mysql的数据库驱动jar包。

　　● 数据库连接池的jar包。

4.3 整合的步骤

【创建工程】

创建一个java工程

【导入jar包】

前面提到的jar包需要导入，如下图：

【加入配置文件】

　　● SqlMapConfig.xml.xml配置文件

　　● applicationContext.xml配置文件：

　　　　a) 数据库连接及连接池

　　　　b) 事务管理（暂时可以不配置）

　　　　c) sqlsessionFactory对象，配置到spring容器中

　　　　d) mapeer代理对象或者是dao实现类配置到spring容器中。

【SqlMapConfig.xml】

配置文件是SqlMapConfig.xml，如下：

<?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>
    <!-- 设置别名 -->
    <typeAliases>
        <!-- 2. 指定扫描包，会把包内所有的类都设置别名，别名的名称就是类名，大小写不敏感 -->
        <package name="com.kevin.entity" />
    </typeAliases>
    
    <mappers>
        <package name="com.kevin.mapper"/>
    </mappers>

</configuration>

【applicationContext.xml】

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    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"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-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/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
    
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <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="maxActive" value="10" />
        <property name="maxIdle" value="5" />
    </bean>
    
    <!-- mybatis工厂 -->
    <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 配置数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 配置mybatis核心配置文件 -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
    </bean>
    
    
</beans>    

【db.properties】

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

【log4j.properties】

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# 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

4.4  Dao的开发

两种dao的实现方式：

　　● 原始dao的开发方式

　　● 使用Mapper代理形式开发方式

　　　　a) 直接配置Mapper代理

　　　　b) 使用扫描包配置Mapper代理

需求：

1. 实现根据用户id查询

2. 实现根据用户名模糊查询

3. 添加用户

　　传统方式Dao开发可参考Mybatis学习笔记之一（环境搭建和入门案例介绍），下面主要介绍Mapper动态代理形式开发。

4.5 Mapper代理形式开发

【实现Mapper.xml】

编写UserMapper.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.kevin.mapper.UserMapper">
    
    <select id="findUserById" parameterType="Integer" resultType="User">
        select * from User where id = #{id}
    </select>

</mapper>

【实现UserMapper接口】

package com.kevin.mapper;

import java.util.List;

import com.kevin.entity.User;

public interface UserMapper {
    
    public User findUserById(Integer id);

} 

方式一：配置mapper代理

在applicationContext.xml添加配置

<!-- mapper动态代理开发 -->
    <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="sqlSessionFactory" ref="sqlSessionFactoryBean"></property>
        <property name="mapperInterface" value="com.kevin.mapper.UserMapper"></property>
    </bean>

【测试方法】

    /*
     * mapper动态代理开发
     */
    @Test
    public void findUserById(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//        context.getBean(UserMapper.class);
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        User user = userMapper.findUserById(1);
        System.out.println(user);
        
    }

方式二：扫描包形式配置mapper

在applicationContext.xml添加配置

    <!-- mapper动态代理开发，扫描 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 基本包 -->
        <property name="basePackage" value="com.kevin.mapper"></property>
    </bean>

【测试方法】

/*
     * 增强mapper动态代理开发
     */
    @Test
    public void findUserById2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper mapper = context.getBean(UserMapper.class);
        User user = mapper.findUserById(30);
        System.out.println(user);
        
    }