Mybatis框架学习（二）

最新推荐文章于 2023-08-10 19:20:13 发布

zhangjun62

最新推荐文章于 2023-08-10 19:20:13 发布

阅读量428

点赞数 1

分类专栏：框架文章标签： JavaEE 框架 Mybatis

本文链接：https://blog.csdn.net/zhangjun62/article/details/89571156

版权

框架专栏收录该内容

15 篇文章 0 订阅

订阅专栏

入输出映射

parammeterType(输入类型)

简单类型

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

传递pojo对象

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

传递pojo包装对象

开发中可以使用pojo传递查询对象

查询条件可能是综合查询条件，不仅包括用户查询条件还包括其他查询条件

编写QueryVo

/**
 * 包装的pojo
 * @author jzhang
 *
 */
public class QueryVo{
   private User user;

   public User getUser() {
      return user;
   }

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

sql配置

<select id="getUserByQueryVo" parameterType="queryvo" resultType="user">
    SELECT
    `id`,
    `username`,
    `birthday`,
    `sex`,
    `address`
    FROM `user`
    WHERE `username` LIKE '%${user.username}%'
</select>

UserMapper接口添加List<User> getUserByQueryVo(QueryVo vo)方法

编写测试代码

@Test
public void testGetUserByQueryVo(){
    SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtil.getSqlSessionFactory();
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    QueryVo vo = new QueryVo();
    User user = new User();
    user.setUsername("张");
    vo.setUser(user);
    List<User> list = userMapper.getUserByQueryVo(vo);
    for (User u : list) {
        System.out.println(u);
    }
}

resultType(输出类型)

输出简单类型

sql配置

<select id="getUserCount" resultType="int">
   SELECT COUNT(1) FROM `user`
</select>

UserMapper接口添加Integer getUserCount()方法

编写测试代码

@Test
public void testGetUserCount() {
    SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    int count = userMapper.getUserCount();
    System.out.println("用户总记录数:"+count);

    sqlSession.close();
}

输出pojo对象

输出pojo列表

resultMap

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

   Order类

order表

其中表中的列user_id与pojo中userId属性名称不一致

sql配置

<?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 namespace="cn.zjut.mybatis.mapper.OrderMapper">
   <select id="getOrderList" resultType="order">
      SELECT
         `id`,
         `user_id`,
         `number`,
         `createtime`,
         `note`
      FROM `order`
   </select>
</mapper>

OrderMapper接口添加List<Order> getOrderList()方法

编写测试代码

@Test
public void testGetOrderList() {
   SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
   OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
   List<Order> list = orderMapper.getOrderList();
   for (Order order : list) {
      System.out.println(order);
   }
   sqlSession.close();
}

结果显示

可以查询时用pojo属性名来作为不一致的一列的别名进行查询

<select id="getOrderList" resultType="order">
   SELECT
      `id`,
      `user_id` userId,
      `number`,
      `createtime`,
      `note`
   FROM `order`
</select>

还可以使用resultMap

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

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

使用 resultMap解决不一致映射问题

sql配置

<resultMap id="order_list_map" type="order">
   <!--主键字段-->
   <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="getOrderListMap" resultMap="order_list_map">
   SELECT
      `id`,
      `user_id`,
      `number`,
      `createtime`,
      `note`
   FROM `order`
</select>

OrderMapper接口添加List<Order> getOrderListMap()方法

编写测试代码

@Test
public void testGetOrderListMap(){
   SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
   OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
   List<Order> list = orderMapper.getOrderListMap();
   for (Order order : list) {
      System.out.println(order);
   }
   sqlSession.close();
}

结果显示

动态sql

mybatis提供各种标签实现动态sql拼接

if标签

sql配置

<select id="getUserByPojo" parameterType="user" resultType="user">
    SELECT
    `id`,
    `username`,
    `birthday`,
    `sex`,
    `address`
    FROM `user`
    WHERE 1 = 1
    <if test="username != null and username != ''">
        AND `username` LIKE '%${username}%'
    </if>
    <if test="sex != null and sex != ''">
        AND `sex` = #{sex}
    </if>
</select>

UserMapper接口添加List<User> getUserByPojo(User user)方法

测试代码

@Test
public void testGetUserByPojo(){
    SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = new User();
    user.setUsername("张");
    user.setSex("1");
    List<User> list = userMapper.getUserByPojo(user);
    for (User u : list) {
        System.out.println(u);
    }
}

where标签

sql配置

<select id="getUserByPojo" parameterType="user" resultType="user">
    SELECT
    `id`,
    `username`,
    `birthday`,
    `sex`,
    `address`
    FROM `user`
    <!--where标签可以自动添加where关键字,同时处理sql语句中多余的and关键字-->
    <where>
        <if test="username != null and username != ''">
            AND `username` LIKE '%${username}%'
        </if>
        <if test="sex != null and sex != ''">
            AND `sex` = #{sex}
        </if>
    </where>
</select>

sql标签抽取sql片段

<!--sql片段抽取-->
<sql id="user_sql">
      `id`,
      `username`,
      `birthday`,
      `sex`,
      `address`
</sql>

<select id="getUserById" parameterType="int" resultType="user">
    SELECT
    <!--sql片段使用 refid为已定义的sql片段id-->
    <include refid="user_sql"/>
    FROM `user`
    WHERE `id` = #{id}
</select>

foreach标签

sql配置

<select id="getUserByIds" parameterType="queryvo" resultType="user">
    SELECT
    <include refid="user_sql"/>
    FROM `user`
    <where>
        <!-- foreach循环标签
         collection:遍历的集合
         open:循环开始之前的输出内容
         item:循环变量
         separator:分隔符
         close:循环结束之后输出的内容
        -->
        <foreach collection="ids" open="`id` IN(" item="uId" separator="," close=")">
            #{uId}
        </foreach>
    </where>
</select>

UserMapper接口添加List<User> getUserByIds(QueryVo vo)方法

QueryVo添加List<Integer> ids属性并提供get/set方法

测试代码

@Test
public void testGetUserByIds() {
    SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    QueryVo vo = new QueryVo();

    vo.setIds(Arrays.asList(1, 25, 29, 30));

    List<User> list = userMapper.getUserByIds(vo);
    for (User user : list) {
        System.out.println(user);
    }
    sqlSession.close();
}

关联查询

查询所有订单信息并关联到对应用户信息

方式一使用resultType

创建OrderUser pojo类

public class OrderUser extends Order {
    private String username;// 用户姓名
    private String address;// 地址

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

sql配置

<select id="getOrderUser" 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 u.`id` = o.`user_id`
</select>

OrderMapper接口添加List<OrderUser> getOrderUser()方法

测试代码

@Test
public void testGetOrderUser() {
   SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
   OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
   List<OrderUser> list = orderMapper.getOrderUser();
   for (OrderUser orderUser : list) {
      System.out.println(orderUser);
   }
   sqlSession.close();
}

方式二使用resultMap

Order pojo类添加User user对象属性

sql配置

<resultMap id="order_user_map" type="order">
   <!--主键字段-->
   <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"/>

   <!--
   association用于配置多对一关系
   property多的一方里的一的一方对象名称
   javaType一的一方类全路径名,支持别名
   -->
   <association property="user" javaType="cn.zjut.mybatis.pojo.User">
      <id property="id" column="user_id"/>

      <result property="username" column="username"/>
      <result property="address" column="address"/>
      <result property="birthday" column="birthday"/>
      <result property="sex" column="sex"/>
   </association>
</resultMap>
<select id="getOrderUserMap" resultMap="order_user_map">
   SELECT
     o.`id`,
     o.`user_id`,
     o.`number`,
     o.`createtime`,
     o.`note`,
     u.`username`,
     u.`address`,
     u.`birthday`,
     u.`sex`
   FROM
     `order` o
   LEFT JOIN `user` u
   ON u.`id` = o.`user_id`
</select>

OrderMapper接口添加List<Order> getOrderUserMap()方法

测试代码

@Test
public void testGetOrderUserMap(){
   SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
   OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
   List<Order> list = orderMapper.getOrderUserMap();
   for (Order order : list) {
      System.out.println(order);
      System.out.println("此订单用户为: " + order.getUser());
   }
   sqlSession.close();
}

一对多查询，查询用户关联查询所有订单信息

User pojo类添加List<Order> orders对象属性

sql配置

<resultMap id="user_order_map" type="user">
    <id property="id" column="id"/>

    <result property="username" column="username"/>
    <result property="birthday" column="birthday"/>
    <result property="sex" column="sex"/>
    <result property="address" column="address"/>
    <result property="uuid2" column="uuid2"/>

    <!--
    collection用于配置一对多关联
    property一的一方里的多的一方集合属性
    ofType多的一方类全路径,支持别名
    -->
    <collection property="orders" ofType="cn.zjut.mybatis.pojo.Order">
        <id property="id" column="oid"/>

        <result property="userId" column="id"/>
        <result property="number" column="number"/>
        <result property="createtime" column="createtime"/>
        <result property="note" column="note"/>
    </collection>
</resultMap>
<select id="getUserOrderMap" resultMap="user_order_map">
    SELECT
      u.`id`,
      u.`username`,
      u.`birthday`,
      u.`sex`,
      u.`address`,
      u.`uuid2`,
      o.`id` oid,
      o.`number`,
      o.`createtime`,
      o.`note`
    FROM
      `user` u
    LEFT JOIN `order` o
    ON o.`user_id` = u.`id`

</select>

UserMapper接口添加List<User> getUserOrderMap()方法

测试代码

@Test
public void testGetUserOrderMap(){
    SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    List<User> list = userMapper.getUserOrderMap();
    for (User user: list) {
        System.out.println(user);
        for (Order order: user.getOrders()) {
            if (order.getId() != null)
                System.out.println("此用户订单: "+order);
        }
    }
}

Spring和Mybatis整合

创建工程

导入jar包

加入配置文件

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>

</configuration>

applicationContext

<?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
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans ">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:jdbc.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>
    <!-- SqlSessionFactory配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!-- 加载mybatis核心配置文件 -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml"/>
        <!-- 别名包扫描 -->
        <property name="typeAliasesPackage" value="cn.zjut.mybatis.pojo"/>
    </bean>
</beans>

创建cn.zjut.mybatis.pojo包

src添加log4j.properties、jdbc.properties文件

Dao开发

传统Dao开发

user.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="user">
    <select id="getUserById" parameterType="int" resultType="user">
        SELECT
          `id`,
          `username`,
          `birthday`,
          `sex`,
          `address`
        FROM `user`
        WHERE `id` = #{id}
    </select>
    <select id="getUserByUserName" parameterType="string" resultType="user">
        SELECT
          `id`,
          `username`,
          `birthday`,
          `sex`,
          `address`
        FROM `user`
        WHERE `username` LIKE '%${value}%'
    </select>
    <insert id="insertUser" parameterType="user">
      INSERT INTO `user`
                  (`username`,
                    `birthday`,
                    `sex`,
                     `address`)
            VALUES
                 (#{username},
                  #{birthday},
                  #{sex},
                 #{address})
   </insert>
</mapper>

加载user.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>
    <mappers>
        <mapper resource="user.xml" />
    </mappers>
</configuration>

创建pojo对象

import java.util.Date;

public class User {

   private Integer id;
   private String username;// 用户姓名
   private String sex;// 性别
   private Date birthday;// 生日
   private String address;// 地址
   private String uuid2;//uuid2

   public String getUuid2() {
      return uuid2;
   }

   public void setUuid2(String uuid2) {
      this.uuid2 = uuid2;
   }

   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 "id=" + id + ", username=" + username + ", sex=" + sex + ", birthday=" + birthday + ", address="
            + address + "uuid2=" + uuid2;
   }

}

import java.util.Date;

public class Order {
   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 "id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
            + ", note=" + note;
   }

}

创建UserDao接口及实现类UserDaoImpl

import cn.zjut.mybatis.pojo.User;

import java.util.List;

public interface UserDao {
    User getUserById(Integer id);
    List<User> getUserByUserName(String userName);
    void insertUser(User user);
}

import cn.zjut.mybatis.dao.UserDao;
import cn.zjut.mybatis.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserDaoImpl  extends SqlSessionDaoSupport implements UserDao {
    @Override
    public User getUserById(Integer id) {
        SqlSession sqlSession = this.getSqlSession();
        User user = sqlSession.selectOne("user.getUserById", id);
        //这里不能关闭SqlSession,SqlSession由spring管理
        return user;
    }

    @Override
    public List<User> getUserByUserName(String userName) {
        SqlSession sqlSession = this.getSqlSession();
        List<User> list = sqlSession.selectList("user.getUserByUserName", userName);
        return list;
    }

    @Override
    public void insertUser(User user) {
        SqlSession sqlSession = this.getSqlSession();
        sqlSession.insert("user.insertUser", user);
	//事务交由spring管理
    }
}

spring 配置Dao

<!-- 传统Dao配置 -->
<bean id="userDao" class="cn.zjut.mybatis.dao.impl.UserDaoImpl">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

测试代码

import cn.zjut.mybatis.dao.UserDao;
import cn.zjut.mybatis.pojo.User;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

public class UserDaoTest {
    private ApplicationContext applicationContext;
    @Before
    public void init(){

        applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }
    @Test
    public void testGetUserById(){
        UserDao userDao = applicationContext.getBean(UserDao.class);
        User user = userDao.getUserById(28);
        System.out.println(user);
    }

    @Test
    public void testGetUserByUserName(){
        UserDao userDao = applicationContext.getBean(UserDao.class);
        List<User> list = userDao.getUserByUserName("张");
        for (User user: list) {
            System.out.println(user);
        }
    }
    @Test
    public void testInsertUser(){
        UserDao userDao = applicationContext.getBean(UserDao.class);
        User user = new User();
        user.setUsername("关昀");
        user.setSex("1");
        user.setBirthday(new Date());
        user.setAddress("杭州千岛湖");
        userDao.insertUser(user);
    }
}

动态代理方式开发

创建UserMapper接口类和UserMapper.xml映射文件

import cn.zjut.mybatis.pojo.User;

import java.util.List;

public interface UserMapper {
    User getUserById(Integer id);
    List<User> getUserByUserName(String userName);
    void insertUser(User user);
}

<?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="cn.zjut.mybatis.mapper.UserMapper">
    <sql id="user_sql">
          `id`,
          `username`,
          `birthday`,
          `sex`,
          `address`
    </sql>
    <select id="getUserById" parameterType="int" resultType="user">
        SELECT
        <include refid="user_sql"/>
        FROM `user`
        WHERE `id` = #{id}
    </select>

    <select id="getUserByUserName" parameterType="string" resultType="user">
        SELECT
        <include refid="user_sql"/>
        FROM `user`
        WHERE `username` LIKE '%${value}%'
    </select>

    <insert id="insertUser" parameterType="user">
      INSERT INTO `user`
                  (`username`,
                    `birthday`,
                    `sex`,
                     `address`)
            VALUES
                 (#{username},
                  #{birthday},
                  #{sex},
                 #{address})
   </insert>
</mapper>

spring配置动态代理

<!-- 动态代理方式配置 第一种方式 -->
<!--
<bean id="baseMapper" class="org.mybatis.spring.mapper.MapperFactoryBean" abstract="true" lazy-init="true">
     <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>
-->
<!-- 配置一个接口 -->
<!--
<bean parent="baseMapper">
      <property name="mapperInterface" value="cn.zjut.mybatis.mapper.UserMapper" />
</bean>
-->

<!-- 动态代理方式配置 第二种方式 -->
<!-- 包扫描 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- basePackage：配置映射包装扫描，多个包时用","或";"分隔 -->
    <property name="basePackage" value="cn.zjut.mybatis.mapper" />
</bean>

测试代码

import cn.zjut.mybatis.mapper.UserMapper;
import cn.zjut.mybatis.pojo.User;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

public class UserMapperTest {
    private ApplicationContext applicationContext;
    @Before
    public void init(){
        applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }
    @Test
    public void testGetUserById(){
        UserMapper userMapper = applicationContext.getBean(UserMapper.class);
        User user = userMapper.getUserById(28);
        System.out.println(user);
    }
    @Test
    public void testGetUserByUserName(){
        UserMapper userMapper = applicationContext.getBean(UserMapper.class);
        List<User> list = userMapper.getUserByUserName("张");
        for (User user: list) {
            System.out.println(user);
        }
    }
    @Test
    public void testInsertUser(){
        UserMapper userMapper = applicationContext.getBean(UserMapper.class);
        User user = new User();
        user.setUsername("关一发");
        user.setSex("1");
        user.setBirthday(new Date());
        user.setAddress("杭州上城");
        userMapper.insertUser(user);
    }
}

mybatis逆向工程

创建工程generatorSqlmapCustom

导入jar包

src目录下导入log4j.properties文件

log4j.rootLogger=DEBUG, Console
#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

工程目录下创建生成配置文件generatorConfig.xml

<?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="1234">
      </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.zjut.ssm.pojo"
         targetProject=".\src">
         <!-- enableSubPackages:是否让schema作为包的后缀 -->
         <property name="enableSubPackages" value="false" />
         <!-- 从数据库返回的值被清理前后的空格 -->
         <property name="trimStrings" value="true" />
      </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
      <sqlMapGenerator targetPackage="cn.zjut.ssm.mapper"
         targetProject=".\src">
         <!-- enableSubPackages:是否让schema作为包的后缀 -->
         <property name="enableSubPackages" value="false" />
      </sqlMapGenerator>
      <!-- targetPackage：mapper接口生成的位置 -->
      <javaClientGenerator type="XMLMAPPER"
         targetPackage="cn.zjut.ssm.mapper"
         targetProject=".\src">
         <!-- enableSubPackages:是否让schema作为包的后缀 -->
         <property name="enableSubPackages" value="false" />
      </javaClientGenerator>
      <!-- 指定数据库表 -->
      <table schema="" tableName="user"></table>
      <table schema="" tableName="order"></table>
      
      <!-- 有些表的字段需要指定java类型
       <table schema="" tableName="">
         <columnOverride column="" javaType="" />
      </table> -->
   </context>
</generatorConfiguration>

在src目录下创建逆向工程类GeneratorSqlmap

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class GeneratorSqlmap {
    public void generator() throws Exception{

        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        //指定 逆向工程配置文件
        File configFile = new File("generatorConfig.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        myBatisGenerator.generate(null);

    }
    public static void main(String[] args) throws Exception {
        try {
            GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行程序main，将生成的包和文件拷贝到所需工程中

Spring配置包扫描，加载映射文件

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="cn.zjut.ssm.mapper"/>
</bean>

创建测试类UserMapperGTest及编写测试程序

import cn.zjut.ssm.mapper.UserMapper;
import cn.zjut.ssm.pojo.User;
import cn.zjut.ssm.pojo.UserExample;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class UserMapperGTest {
    private ApplicationContext applicationContext;

    @Before
    public void init(){
        applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    }
    //如果相应字段为空 则对应的表字段不插入数据
    //Preparing: insert into user ( username, address ) values ( ?, ? )
    //Parameters: 诸葛亮(String), 杭州富阳(String)
    @Test
    public void testInsertSelective() {
        UserMapper userMapper = applicationContext.getBean(UserMapper.class);
        User user = new User();
        user.setUsername("诸葛亮");
        user.setAddress("杭州富阳");
        userMapper.insertSelective(user);
    }
    /**
     * 按照主键查询用户
     */
    @Test
    public void testSelectByPrimaryKey() {
        UserMapper userMapper = applicationContext.getBean(UserMapper.class);
        User user = userMapper.selectByPrimaryKey(28);
        System.out.println(user);
    }

    /**
     * 拼接查询条件
     */
    @Test
    public void testSelectByExample() {
        UserMapper userMapper = applicationContext.getBean(UserMapper.class);
        UserExample userExample = new UserExample();
        //创建criteria
        UserExample.Criteria criteria = userExample.createCriteria();
        //设置查询条件
        criteria.andUsernameLike("%张%");
        criteria.andSexEqualTo("2");
        List<User> list = userMapper.selectByExample(userExample);
        for (User user : list) {
            System.out.println(user);
        }
    }
}

zhangjun62

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Mybatis框架学习（二）

入输出映射parammeterType(输入类型)简单类型使用#{}占位符，或者${}进行sql拼接传递pojo对象 Mybatis使用ognl表达式对象字段值，#{}或者${}括号中为pojo对象属性名称传递pojo包装对象开发中可以使用pojo传递查询对象查询条件可能是综合查询条件，不仅包括用户查询条件还包括...
复制链接

扫一扫