SSM————Mybitis（2）

一、输入输出映射

　　Mapper.xml映射文件中定义了操作数据库的sql，每个sql是一个statement，映射文件是mybatis的核心。

　　1、环境准备

 　　　　（1）复制昨天的工程，按照下图进行

　　　　

　　　　（2）下图粘贴，并更名

　　　　

 　　　　（3）只保留Mapper接口开发相关的文件，其他删除

　　　　　　最终效果图：

　　　　

　　　　（4）如下图修改SqlMapConfig.xml配置文件。Mapper映射器只保留包扫描的方式

 　　　　

　　2、parameterType（输入类型）

　　　　（1）传递简单类型

　　　　　　参考第一天的内容

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

　　　　（2）传递pojo包装对象

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

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

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

 　　　　（3）编写QuryVo

public class QueryVo {
    // 包含其他的pojo
    private User user;

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

 

 　　　　（4）SQL语句

　　　　　　SELECT * FROM user WHERE username LIKE '%张%

 　　　　（5）Mapper.xml文件

　　　　　　在UserMapper.xml中配置sql，如图所示：

　　　　

　　　　（6）Mapper接口

 　　　　　　在UserMapper接口中添加方法，如图所示：

 　　　　

　　　　（7）测试方法

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

@Test
public void testQueryUserByQueryVo() {
    // mybatis和spring整合，整合之后，交给spring管理
    SqlSession sqlSession = this.sqlSessionFactory.openSession();
    // 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    // 使用userMapper执行查询，使用包装对象
    QueryVo queryVo = new QueryVo();
    // 设置user条件
    User user = new User();
    user.setUsername("张");
    // 设置到包装对象中
    queryVo.setUser(user);

    // 执行查询
    List<User> list = userMapper.queryUserByQueryVo(queryVo);
    for (User u : list) {
        System.out.println(u);
    }

    // mybatis和spring整合，整合之后，交给spring管理
    sqlSession.close();
}

 

 　　　　（8）效果

　　　　　　测试效果图：

 

　　3、resultType（输出类型）

　　　　（1）输出简单类型　　　　　

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

　　　　　　sql：SELECT count(*) FROM `user`

　　　　　　【1】Mapper.xml文件

　　　　　　　　在UserMapper.xml中配置sql，如图所示：

　　　　　　

　　　　　　【2】Mapper接口

　　　　　　　　在UserMapper添加方法，如图所示：

　　　　　　

　　　　　　【3】测试方法

　　　　　　　　在UserMapperTest增加测试方法，如图所示：

@Test
public void testQueryUserCount() {
    // mybatis和spring整合，整合之后，交给spring管理
    SqlSession sqlSession = this.sqlSessionFactory.openSession();
    // 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    // 使用userMapper执行查询用户数据条数
    int count = userMapper.queryUserCount();
    System.out.println(count);

    // mybatis和spring整合，整合之后，交给spring管理
    sqlSession.close();
}

 

　　　　　　【4】效果

 　　　　

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

 　　　　（2）输出pojo对象

 　　　　　　参考第一天的内容

　　　　（3）输出pojo列表

 　　　　　　参考第一天的内容

　　4、resultMap

　　resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。

如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系 ，resultMap实质上还需要将查询结果映射到pojo对象中。

resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

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

sql：SELECT id, user_id, number, createtime, note FROM `order` 

 　　　　（1）声明pojo对象

 　　　　　　数据库表如图：

　　　　

　　　　　　Order对象

public class Order {
    // 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;
get/set。。。
}

 

　　　　（2）Mapper.xml文件

　　　　创建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">
<!-- namespace：命名空间，用于隔离sql，还有一个很重要的作用，Mapper动态代理开发的时候使用，需要指定Mapper的类路径 -->
<mapper namespace="cn.itcast.mybatis.mapper.OrderMapper">
    <!-- 查询所有的订单数据 -->
    <select id="queryOrderAll" resultType="order">
        SELECT id, user_id,
        number,
        createtime, note FROM `order`
    </select>
</mapper>

 

 　　　　（3）Mapper接口

 　　　　接口编写如下：

public interface OrderMapper {
    /**
     * 查询所有订单
     * 
     * @return
     */
    List<Order> queryOrderAll();
}

 

 　　　　（4）测试方法

　　　　编写测试方法OrderMapperTest如下：

public class OrderMapperTest {
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void init() throws Exception {
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        this.sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    @Test
    public void testQueryAll() {
        // 获取sqlSession
        SqlSession sqlSession = this.sqlSessionFactory.openSession();
        // 获取OrderMapper
        OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);

        // 执行查询
        List<Order> list = orderMapper.queryOrderAll();
        for (Order order : list) {
            System.out.println(order);
        }
    }
}

 

 　　　　（5）效果

 　　　　

　　　　　　发现userId为null

　　　　　　解决方案：使用resultMap

 　　　　（6）使用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">
<!-- namespace：命名空间，用于隔离sql，还有一个很重要的作用，Mapper动态代理开发的时候使用，需要指定Mapper的类路径 -->
<mapper namespace="cn.itcast.mybatis.mapper.OrderMapper">

    <!-- resultMap最终还是要将结果映射到pojo上，type就是指定映射到哪一个pojo -->
    <!-- id：设置ResultMap的id -->
    <resultMap type="order" id="orderResultMap">
        <!-- 定义主键 ,非常重要。如果是多个字段,则定义多个id -->
        <!-- property：主键在pojo中的属性名 -->
        <!-- column：主键在数据库中的列名 -->
        <id property="id" column="id" />

        <!-- 定义普通属性 -->
        <result property="userId" column="user_id" />
        <result property="number" column="number" />
        <result property="createtime" column="createtime" />
        <result property="note" column="note" />
    </resultMap>

    <!-- 查询所有的订单数据 -->
    <select id="queryOrderAll" resultMap="orderResultMap">
        SELECT id, user_id,
        number,
        createtime, note FROM `order`
    </select>

</mapper>

 

 　　　　（7）效果

　　　　　　只需要修改Mapper.xml就可以了，再次测试结果如下：

　　　　

二、动态sql

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

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

　　查询sql:

　SELECT id, username, birthday, sex, address FROM `user` WHERE sex = 1 AND username LIKE '%张%'

 

　　1、if标签

　　　　（1）Mapper.xml文件

　　　　UserMapper.xml配置sql，如下：

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
    SELECT id, username, birthday, sex, address FROM `user`
    WHERE sex = #{sex} AND username LIKE
    '%${username}%'
</select>

 

　　　　（2）Mapper接口

　　　　编写Mapper接口，如图所示：

　　　　（3）测试方法

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

@Test
public void testQueryUserByWhere() {
    // mybatis和spring整合，整合之后，交给spring管理
    SqlSession sqlSession = this.sqlSessionFactory.openSession();
    // 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    // 使用userMapper执行根据条件查询用户
    User user = new User();
    user.setSex("1");
    user.setUsername("张");

    List<User> list = userMapper.queryUserByWhere(user);

    for (User u : list) {
        System.out.println(u);
    }

    // mybatis和spring整合，整合之后，交给spring管理
    sqlSession.close();
}

　　　　（4）效果

　　　　

　　　　如图所示，测试ok

 　　2、Where标签

 　　上面的sql还有where 1=1 这样的语句，很麻烦

　　 可以使用where标签进行改造

　　 改造UserMapper.xml，如下：

 

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
    SELECT id, username, birthday, sex, address FROM `user`
<!-- where标签可以自动添加where，同时处理sql语句中第一个and关键字 -->
    <where>
        <if test="sex != null">
            AND sex = #{sex}
        </if>
        <if test="username != null and username != ''">
            AND username LIKE
            '%${username}%'
        </if>
    </where>
</select>

 　　测试效果

 

　　3、Sql片段

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

　　把上面例子中的id，username，birthday，sex，address提取出来，作为sql片段，如下：

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
    <!-- SELECT id, username, birthday, sex, address FROM `user` -->
    <!-- 使用include标签加载sql片段；refid是sql片段id -->
    SELECT <include refid="userFields" /> FROM `user`
    <!-- where标签可以自动添加where关键字，同时处理sql语句中第一个and关键字 -->
    <where>
        <if test="sex != null">
            AND sex = #{sex}
        </if>
        <if test="username != null and username != ''">
            AND username LIKE
            '%${username}%'
        </if>
    </where>
</select>

<!-- 声明sql片段 -->
<sql id="userFields">
    id, username, birthday, sex, address
</sql>

 

　　如果使用别的Mapper.xml配置的sql片段，可以在refid前面加上对应的Mapper.xml的namespace

　　例如下图：

　　

　　4、foreach标签

　　　　向sql传递数组或List，mybatis使用foreach解析，如下：

　　　　根据多个id查询用户信息

　　　　查询sql：

SELECT * FROM user WHERE id IN (1,10,24)

 　　　　（1）改造QueryVo

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

 　　　　

　　　　（2）Mapper.xml文件

 　　　　UserMapper.xml添加sql，如下：

<!-- 根据ids查询用户 -->
<select id="queryUserByIds" parameterType="queryVo" resultType="user">
    SELECT * FROM `user`
    <where>
        <!-- foreach标签，进行遍历 -->
        <!-- collection：遍历的集合，这里是QueryVo的ids属性 -->
        <!-- item：遍历的项目，可以随便写，，但是和后面的#{}里面要一致 -->
        <!-- open：在前面添加的sql片段 -->
        <!-- close：在结尾处添加的sql片段 -->
        <!-- separator：指定遍历的元素之间使用的分隔符 -->
        <foreach collection="ids" item="item" open="id IN (" close=")"
            separator=",">
            #{item}
        </foreach>
    </where>
</select>

测试方法如下图：
@Test
public void testQueryUserByIds() {
    // mybatis和spring整合，整合之后，交给spring管理
    SqlSession sqlSession = this.sqlSessionFactory.openSession();
    // 创建Mapper接口的动态代理对象，整合之后，交给spring管理
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    // 使用userMapper执行根据条件查询用户
    QueryVo queryVo = new QueryVo();
    List<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(10);
    ids.add(24);
    queryVo.setIds(ids);

    List<User> list = userMapper.queryUserByIds(queryVo);

    for (User u : list) {
        System.out.println(u);
    }

    // mybatis和spring整合，整合之后，交给spring管理
    sqlSession.close();
}

 

 　　　　（3）效果

 　　　　

 三、Mybatis逆向工程

注：main函数只能运行一遍，如果不小心运行了第二遍，需要把生成的pojo包删了重新运行。

使用官方网站的Mapper自动生成工具mybatis-generator-core-1.3.2来生成po类和Mapper映射文件

　　1、导入逆向工程

　　使用课前资料已有的逆向工程，如图：

　　　　（1）复制逆向工程到工作空间中

 　　　　

　　　　（2）导入逆向工程到eclipse中

 　　　　

　　　　

　　　　

　　2、修改配置文件

 　　generatorConfig.xml中配置Mapper生成的详细信息，如图：

注意修改一下几点：

1、修改要生成的数据库表

2、pojo文件所在包路径

3、Mapper所在的包路径

 

配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <context id="testTables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root" password="root">
        </jdbcConnection>
        <!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver" connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg" 
            userId="yycg" password="yycg"> </jdbcConnection> -->

        <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 
            和 NUMERIC 类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator targetPackage="cn.itcast.ssm.po"
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="cn.itcast.ssm.mapper"
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="cn.itcast.ssm.mapper" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!-- 指定数据库表 -->
        <table schema="" tableName="user"></table>
        <table schema="" tableName="order"></table>
    </context>
</generatorConfiguration>

　　3、生成逆向工程代码

找到下图所示的java文件，执行工程main主函数

刷新工程，发现代码生成，如下图：

 

　　4、测试工程代码

　　　　（1）测试生成的代码到mybatis-spring工程，如下图：

　　　　（2）修改spring配置文件

　　在applicationContext.xml修改

<!-- Mapper代理的方式开发，扫描包方式配置代理 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 配置Mapper接口，如果需要加载多个包，直接写进来，中间用，分隔 -->
    <!-- <property name="basePackage" value="cn.itcast.mybatis.mapper" /> -->
    <property name="basePackage" value="cn.itcast.ssm.mapper" />
</bean>

 

 　　　　（3）编写测试方法：

public class UserMapperTest {
    private ApplicationContext context;

    @Before
    public void setUp() throws Exception {
        this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }

    @Test
    public void testInsert() {
        // 获取Mapper
        UserMapper userMapper = this.context.getBean(UserMapper.class);

        User user = new User();
        user.setUsername("曹操");
        user.setSex("1");
        user.setBirthday(new Date());
        user.setAddress("三国");

        userMapper.insert(user);
    }

    @Test
    public void testSelectByExample() {
        // 获取Mapper
        UserMapper userMapper = this.context.getBean(UserMapper.class);

        // 创建User对象扩展类，用户设置查询条件
        UserExample example = new UserExample();
        example.createCriteria().andUsernameLike("%张%");

        // 查询数据
        List<User> list = userMapper.selectByExample(example);

        System.out.println(list.size());
    }

    @Test
    public void testSelectByPrimaryKey() {
        // 获取Mapper
        UserMapper userMapper = this.context.getBean(UserMapper.class);

        User user = userMapper.selectByPrimaryKey(1);
        System.out.println(user);
    }
}

 

 注意：

1、逆向工程生成的代码只能做单表查询

2、不能在生成的代码上进行扩展，因为如果数据库变更，需要重新使用逆向工程生成代码，原来编写的代码就被覆盖了。

3、一张表会生成4个文件。