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

时间：2021-02-20 14:50:17

一、输入映射和输出映射

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类的所有字段，只需要定义用户的信息字段即可，如下图：

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

【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接口添加方法，如下图：

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

【测试方法】

在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包需要导入，如下图：


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


【加入配置文件】


　　● 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. 

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

  3. 添加用户
    4. 



　　传统方式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);

    }


相关文章