【SSM】mybatis初见

准备：

• JDK1.8
• Eclipse
• mybatis所需jar包
• mysql驱动jar
  

比起hibernate，mybatis要轻量得多（看jar包就知道[偷笑]）

第一步：建立web项目，这里因为后期整合，就直接建立web项目。再就是导入上面提到的包了。建立测试数据库。这里就以mall的products和category为例了。
字段如下了：
category：

products

建立对应实体类（省略getter和setter）：

第二步：在src下配置mybatis-config.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>
<!-- 环境配置，默认为development，有详细的错误信息 -->
  <environments default="development">
  <!-- id不是绝对，可以区分多个环境配置，如不同平台数据库  -->
    <environment id="development">
    <!-- 事务管理配置，可选参数"JDBC"/"MANAGED",JDBC事务管理机制或者spring类型的web容器管理 -->
      <transactionManager type="JDBC"/>
      <!-- type可选参数，POOLED为连接池连接，UNPOOLED为非连接池链接 -->
      <dataSource type="POOLED">
      <!-- 数据库的连接配置 -->
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mall"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
      </dataSource>
    </environment>
  </environments>
  <!-- 指定数据库操作映射文件 -->
  <mappers>
    <mapper resource="mapper/products-mapper.xml"/>
  </mappers>
</configuration>

第三步：配置数据库操作的映射文件以及dao接口

<?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="products_dao.ProductsDao">
  <!-- 添加数据 -->
  <insert id="insertProducts" parameterType="entity.Products">
    insert  into products(pname,price,unitsOnStack) values(#{pname},#{price},#{unitsOnStack})
  </insert>
  <!-- 删除数据 -->
  <delete id="deleteProduct" parameterType="int">
    delete from products where pid = #{pid}
  </delete>
  <!-- 更新数据 -->
  <update id="updateProduct" parameterType="entity.Products">
    update products set pname = #{pname} where pid=#{pid}
  </update>

  <!-- 定义一个结果映射，这里包含了products和category的多对一关系 -->
    <resultMap type="entity.Products" id="product">
        <id column="pid" property="pid" javaType="java.lang.Integer" />
        <result column="pname" property="pname" javaType="java.lang.String" />
        <result column="price" property="price" javaType="java.lang.Double" />
        <result column="unitsOnStack" property="unitsOnStack" javaType="java.lang.Double" />
        <!--association配置多对一多方，实体内包含类型类-->
        <association property="category" column="cid"
            select="queryCategoryByID">
        </association>
    </resultMap>
    <!-- 这是category的结果映射，这里包含了category与products的一对多关系 -->
    <resultMap type="entity.Category" id="category">
        <id column="cid" property="cid" />
        <result column="cname" property="cname" />
        <!--collection配置多对一一方，实体内包含商品集合-->
        <collection property="products" column="cid" select="queryProductsByID"></collection>
    </resultMap>
    <!-- 包含两个表的联合结果映射product1 -->
    <resultMap type="entity.Products" id="product1">
        <id column="pid" property="pid" />
        <result column="pname" property="pname" />
        <association property="category" javaType="entity.Category">
            <id column="cid" property="cid" />
            <result column="cname" property="cname" />
            <collection property="products" resultMap="product1"></collection>
        </association>
    </resultMap>

    <!-- 通过id查询的结果映射到category -->
    <select id="queryCategoryByID" parameterType="int" resultMap="category">
        select * from category
        where cid=#{cid}
    </select>
    <!-- 通过id查询的结果映射到product -->
    <select id="queryProductsByID" resultMap="product"
        parameterType="int">
        select * from products where cid=#{cid}
    </select>
    <!-- 将查询的内容映射到product对应的结果映射  -->
    <select id="queryProducts" resultMap="product">
        select * from products
    </select>
      <!-- 将查询的内容映射到category对应的结果映射 -->
    <select id="queryCategory" resultMap="category">
        select * from category
    </select>
  <!-- 最后通过两个表的结果映射所得到的结果 -->
  <select id="queryProductsByUnion" resultMap="product1">
        select * from
        mall.products a left join mall.category b on a.cid=b.cid;
    </select>
  <!-- 动态查询 -->
  <select id="queryProductsByCondition" parameterType="entity.Products" 
  resultType="entity.Products">
  select * from products
  <!-- trim加where前缀和去掉重复的and -->
  <trim prefix="where" suffixOverrides="and">
        <if test="pname != null">
            pname = #{pname} and
        </if>
        <if test="price != null">
            price = #{price} and
        </if>
        <if test="unitsOnStack != null">
            unitsOnStack = #{unitsOnStack}
        </if>
  </trim>
  </select>
</mapper>

dao接口：

package products_dao;

import java.util.List;
import entity.Products;

public interface ProductsDao {
    List<Products> queryProducts();
    int insertProducts(Products pro);
    int deleteProduct(int pid);
    int updateProduct(Products pro);
    List<Products> queryProductsByUnion();
    List<Products> queryProductsByCondition(Products pro);
}

当 查询的数据不是实体类中存在，而是一些特殊业务场景，如联表统计销售额等等，使用返回值类型为map集合就很适合此时的业务，从而没有必要去建立一个实体类

第四步：测试

package test;

import java.io.IOException;
import java.io.Reader;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import entity.Products;
import products_dao.ProductsDao;

public class PrdouctTest {
    public static void main(String[] args) throws IOException {
        String configPath = "mybatis-config.xml";
        //  读取配置
        Reader reader = Resources.getResourceAsReader(configPath);
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(reader);
        SqlSession session = factory.openSession();

        //  查询
        //  通过接口映射所对应执行的sql语句
        ProductsDao dao = session.getMapper(ProductsDao.class);
        List<Products> list = dao.queryProducts();
        for (Products products : list) {
            System.out.println(products.getPname());
        }

        //  添加
        Products pro = new Products();
        pro.setPname("嘻嘻");
        pro.setPrice(4.0);
        pro.setUnitsOnStack(100.0);

        int rs = dao.insertProducts(pro);
        if(rs>0) {
            System.out.println("恭喜你插入成功");
        }else{
            System.out.println("恭喜你插入失败");
        }
        session.commit();

        // 删除
        int rs1 = dao.deleteProduct(9);
        if(rs1>0) {
            System.out.println("恭喜你删除成功");
        }else{
            System.out.println("恭喜你删除失败");
        }
        session.commit();

        // 更新
        Products pro1 = new Products();
        pro1.setPid(8);
        pro1.setPname("辣条");
        int rs2 = dao.updateProduct(pro1);
        if(rs2>0) {
            System.out.println("恭喜你修改成功");
        }else{
            System.out.println("恭喜你修改失败");
        }
        session.commit();

        // 联表查询
        List<Products> list1=dao.queryProductsByUnion();
        for(Products pro2:list1){
            System.out.println(pro2.getPid()+"  "+pro2.getCategory().getCname());
        }

        // 动态查询
        Products pro3 = new Products();
        pro.setPname("辣条");
        List<Products> list2=dao.queryProductsByCondition(pro3);
        System.out.println(list2.size());

    }
}

写的比较仓促，基本用法都有了。有时间再补充一下。