zoukankan      html  css  js  c++  java

  • Mybatis 入门到理解篇

    MyBatis

            MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。

         本教程是用maven构建项目、不会maven的看这篇文章！-----Maven教程
    • 开发工具：idea
    • 语言：java
    • 项目结构：maven项目
    • mysql数据库

        本教程有 MyBatis三种开发方式：

           mybatis本地调试、代理开发方式、传统开发方式！

     

     

    1、入门案例

    1.1、db.properties文件

    [java] view plain copy
     
    1. <span style="font-size:18px;">jdbc.driver=com.mysql.jdbc.Driver  
    2. jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8  
    3. jdbc.username=用户名  
    4. jdbc.password=密码</span>  

    1.1.1SQL语句、数据表

    [java] view plain copy
     
    1. /* 
    2. SQLyog v10.2  
    3. MySQL - 5.1.72-community : Database - mybatis 
    4. ********************************************************************* 
    5. */  
    6. /*Table structure for table `items` */  
    7.   
    8. CREATE TABLE `items` (  
    9.   `id` int(11) NOT NULL AUTO_INCREMENT,  
    10.   `name` varchar(32) NOT NULL COMMENT '商品名称',  
    11.   `price` float(10,1) NOT NULL COMMENT '商品定价',  
    12.   `detail` text COMMENT '商品描述',  
    13.   `pic` varchar(64) DEFAULT NULL COMMENT '商品图片',  
    14.   `createtime` datetime NOT NULL COMMENT '生产日期',  
    15.   PRIMARY KEY (`id`)  
    16. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;  
    17.   
    18. /*Table structure for table `orderdetail` */  
    19.   
    20. CREATE TABLE `orderdetail` (  
    21.   `id` int(11) NOT NULL AUTO_INCREMENT,  
    22.   `orders_id` int(11) NOT NULL COMMENT '订单id',  
    23.   `items_id` int(11) NOT NULL COMMENT '商品id',  
    24.   `items_num` int(11) DEFAULT NULL COMMENT '商品购买数量',  
    25.   PRIMARY KEY (`id`),  
    26.   KEY `FK_orderdetail_1` (`orders_id`),  
    27.   KEY `FK_orderdetail_2` (`items_id`),  
    28.   CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,  
    29.   CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION  
    30. ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;  
    31.   
    32. /*Table structure for table `orders` */  
    33.   
    34. CREATE TABLE `orders` (  
    35.   `id` int(11) NOT NULL AUTO_INCREMENT,  
    36.   `user_id` int(11) NOT NULL COMMENT '下单用户id',  
    37.   `number` varchar(32) NOT NULL COMMENT '订单号',  
    38.   `createtime` datetime NOT NULL COMMENT '创建订单时间',  
    39.   `note` varchar(100) DEFAULT NULL COMMENT '备注',  
    40.   PRIMARY KEY (`id`),  
    41.   KEY `FK_orders_1` (`user_id`),  
    42.   CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION  
    43. ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;  
    44.   
    45. /*Table structure for table `user` */  
    46.   
    47. CREATE TABLE `user` (  
    48.   `id` int(11) NOT NULL AUTO_INCREMENT,  
    49.   `username` varchar(32) NOT NULL COMMENT '用户名称',  
    50.   `birthday` date DEFAULT NULL COMMENT '生日',  
    51.   `sex` char(1) DEFAULT NULL COMMENT '性别',  
    52.   `address` varchar(256) DEFAULT NULL COMMENT '地址',  
    53.   PRIMARY KEY (`id`)  
    54. ) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;  

    插入数据：

    [java] view plain copy
     
    1. /* 
    2. SQLyog v10.2  
    3. MySQL - 5.1.72-community : Database - mybatis 
    4. ********************************************************************* 
    5. */  
    6. /*Data for the table `items` */  
    7.   
    8. insert  into `items`(`id`,`name`,`price`,`detail`,`pic`,`createtime`) values (1,'台式机',3000.0,'该电脑质量非常好！！！！',NULL,'2016-02-03 13:22:53'),(2,'笔记本',6000.0,'笔记本性能好，质量好！！！！！',NULL,'2015-02-09 13:22:57'),(3,'背包',200.0,'名牌背包，容量大质量好！！！！',NULL,'2016-02-06 13:23:02');  
    9.   
    10. /*Data for the table `orderdetail` */  
    11.   
    12. insert  into `orderdetail`(`id`,`orders_id`,`items_id`,`items_num`) values (1,3,1,1),(2,3,2,3),(3,4,3,4),(4,4,2,3);  
    13.   
    14. /*Data for the table `orders` */  
    15.   
    16. insert  into `orders`(`id`,`user_id`,`number`,`createtime`,`note`) values (3,1,'1000010','2016-02-04 13:22:35',NULL),(4,1,'1000011','2016-02-03 13:22:41',NULL),(5,10,'1000012','2016-02-12 16:13:23',NULL);  
    17.   
    18. /*Data for the table `user` */  
    19.   
    20. insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'王五',NULL,'2',NULL),(10,'张三','2016-07-10','1','北京市'),(16,'张小明',NULL,'1','河南郑州'),(22,'陈小明',NULL,'1','河南郑州'),(24,'张三丰',NULL,'1','河南郑州'),(25,'陈小明',NULL,'1','河南郑州'),(26,'王五',NULL,NULL,NULL);  


    1.2、pom.xml文件

    [java] view plain copy
     
    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
    3.     <modelVersion>4.0.0</modelVersion>  
    4.     <groupId>web-test-com</groupId>  
    5.     <artifactId>MyBatis</artifactId>  
    6.     <version>0.0.1-SNAPSHOT</version>  
    7.     <packaging>war</packaging>  
    8.   
    9.     <dependencies>  
    10.   
    11.   
    12.         <dependency>  
    13.             <groupId>junit</groupId>  
    14.             <artifactId>junit</artifactId>  
    15.             <version>4.12</version>  
    16.             <scope>provided</scope>  
    17.         </dependency>  
    18.   
    19.         <dependency>  
    20.             <groupId>log4j</groupId>  
    21.             <artifactId>log4j</artifactId>  
    22.             <version>1.2.17</version>  
    23.         </dependency>  
    24.   
    25.         <dependency>  
    26.             <groupId>org.mybatis</groupId>  
    27.             <artifactId>mybatis</artifactId>  
    28.             <version>3.1.1</version>  
    29.         </dependency>  
    30.         <dependency>  
    31.             <groupId>mysql</groupId>  
    32.             <artifactId>mysql-connector-java</artifactId>  
    33.             <version>5.1.38</version>  
    34.         </dependency>  
    35.   
    36.     </dependencies>  
    37.   
    38.   
    39. </project>  

    1.3、SqlMappingConfig.xml文件

    [java] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE configuration  
    3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
    4. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
    5. <configuration>  
    6.   
    7.     <!-- 加载属性文件 -->  
    8.     <properties resource="db.properties">  
    9.         <!--properties中还可以配置一些属性名和属性值 -->  
    10.         <!-- <property name="jdbc.driver" value=""/> -->  
    11.     </properties>  
    12.   
    13.     <!-- 全局配置参数，需要时再设置 -->  
    14.     <!-- <settings> </settings> -->  
    15.   
    16.     <typeAliases>  
    17.         <!-- 别名定义 -->  
    18.         <!-- 针对单个别名定义 type：类型的路径 alias：别名 -->  
    19.         <!-- <typeAlias type="cn.czy.mybatis.po.User" alias="user"/> -->  
    20.         <typeAlias type="cn.com.czy.mybatis.pojo.User" alias="user" />  
    21.         <!-- 批量别名定义 指定包名，mybatis自动扫描包中的po类，自动定义别名，别名就是类名（首字母大写或小写都可以） -->  
    22.         <package name="cn.com.mybatis.mapper" />  
    23.     </typeAliases>  
    24.   
    25.     <!-- 和spring整合后 environments配置将废除 -->  
    26.     <environments default="development">  
    27.         <environment id="development">  
    28.             <!-- 使用jdbc事务管理，事务控制由mybatis -->  
    29.             <transactionManager type="JDBC" />  
    30.             <!-- 数据库连接池，由mybatis管理 -->  
    31.             <dataSource type="POOLED">  
    32.                 <property name="driver" value="${jdbc.driver}" />  
    33.                 <property name="url" value="${jdbc.url}" />  
    34.                 <property name="username" value="${jdbc.username}" />  
    35.                 <property name="password" value="${jdbc.password}" />  
    36.             </dataSource>  
    37.         </environment>  
    38.     </environments>  
    39.   
    40.   
    41.     <!-- 加载 映射文件 -->  
    42.     <mappers>  
    43.       
    44.       
    45.         <!--通过resource方法一次加载一个映射文件 -->  
    46.                 <!--注意这里的路径和xml文件 -->  
    47.                <mapper resource="sqlMapper/user.xml" />  
    48.         <mapper resource="sqlMapper/userMapper.xml" />  
    49.         <mapper resource="sqlMapper/OrdersMapperCustom.xml"/>  
    50.   
    51.         <!-- 批量加载mapper 指定mapper接口的包名，mybatis自动扫描包下边所有mapper接口进行加载 -->  
    52.         <!-- 遵循一些规范：需要将mapper接口类名和mapper.xml映射文件名称保持一致，且在一个目录 -->  
    53.         <!-- 中 上边规范的前提是：使用的是mapper代理方法   
    54.         <package name="cn.com.czy.mybatis.two.mapper" />-->  
    55.           
    56.     </mappers>  
    57.   
    58. </configuration>  

    1.4、user.xml文件（注意在SqlMappingConfig.xml文件中已经引用它）

    [java] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5.   
    6. <mapper namespace="test">  
    7.   
    8.     <!-- 在 映射文件中配置很多sql语句 -->  
    9.     <!-- 将sql语句封装到mappedStatement对象中，所以将id称为statement的id -->  
    10.     <!-- parameterType：指定输入 参数的类型，这里指定int型 #{}表示一个占位符号 -->  
    11.     <!-- #{id}：其中的id表示接收输入 的参数，参数名称就是id，如果输入 -->  
    12.     <!-- 参数是简单类型，#{}中的参数名可以任意，可以value或其它名称 -->  
    13.     <!-- resultType：指定sql输出结果 的所映射的java对象类型，select指定resultType表示将单条记录映射成的java对象。 -->  
    14.     <select id="findUserById" parameterType="int"  resultType="user">  
    15.         SELECT * FROM USER WHERE id=#{value}  
    16.     </select>  
    17. </mapper>  

    1.5、测试类

    [java] view plain copy
     
    1. package cn.com.czy.mybatis.first;  
    2.   
    3. import java.io.IOException;  
    4. import java.io.InputStream;  
    5. import java.util.Date;  
    6. import java.util.List;  
    7.   
    8. import org.apache.ibatis.io.Resources;  
    9. import org.apache.ibatis.session.SqlSession;  
    10. import org.apache.ibatis.session.SqlSessionFactory;  
    11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
    12. import cn.com.czy.mybatis.pojo.User;  
    13. import org.junit.Test;  
    14.   
    15. /** 
    16.  * 《单表映射》 
    17.  * 入门程序总结：这是简单的mybatis入门程序 
    18.  * -- 1、映射(mapper)文件是user.xml --  --  
    19.  * -- 2、逻辑基本的resultType、parameterType等一下基础知识  --  --  
    20.  * -- 3、SqlSessionFactory、SqlSession的原理  --  --  
    21.  */  
    22. public class MybatisFirst {  
    23.   
    24.     public SqlSessionFactory getSqlSessionFactory() throws IOException {  
    25.         // mybatis配置文件  
    26.         String resource = "config/SqlMapConfig.xml";  
    27.         // 得到配置文件流  
    28.         InputStream inputStream = Resources.getResourceAsStream(resource);  
    29.         // 创建会话工厂，传入mybatis的配置文件信息  
    30.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
    31.         return sqlSessionFactory;  
    32.     }  
    33.   
    34.     // 根据id查询用户信息，得到一条记录结果  
    35.     @Test  
    36.     public void findUserByIdTest() throws IOException {  
    37.   
    38.         // 通过工厂得到SqlSession  
    39.         SqlSession sqlSession = this.getSqlSessionFactory().openSession();  
    40.   
    41.         // 通过SqlSession操作数据库  
    42.         // 第一个参数：映射文件中statement的id，等于=namespace+"."+statement的id  
    43.         // 第二个参数：指定和映射文件中所匹配的parameterType类型的参数  
    44.         // sqlSession.selectOne结果 是与映射文件中所匹配的resultType类型的对象  
    45.           
    46.                 // selectOne查询出一条记录（这种很麻烦的！！！往后看看）  
    47.         User user = sqlSession.selectOne("test.findUserById", 1);  
    48.         System.out.println(user);  
    49.         // 释放资源  
    50.         sqlSession.close();  
    51.     }  
    52. }  

     

    1.6、selectOne和selectList的解释

          selectOne表示查询出一条记录进行映射。如果使用selectOne可以实现使用selectList也可以实现（list中只有一个对象）。

          selectList表示查询出一个列表（多条记录）进行映射。如果使用selectList查询多条记录，不能使用selectOne。

    总结：mybatis和hibernate本质区别和应用场景?

        hibernate：是一个标准ORM框架（对象关系映射）。入门门槛较高的，不需要程序写sql，sql语句自动生成了。

    对sql语句进行优化、修改比较困难的。

        mybatis：专注是sql本身，需要程序员自己编写sql语句，sql修改、优化比较方便。mybatis是一个不完全的ORM框架，虽然程序员自己写sql，mybatis 也可以实现映射（输入映射、输出映射）。

          

    2.1、传统的方式写mybatis的应用程序

    2.3、环境搭建

    pom.xml文件

    [java] view plain copy
     
    1. <span style="font-size:18px;"><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
    3.     <modelVersion>4.0.0</modelVersion>  
    4.     <groupId>web-test-com</groupId>  
    5.     <artifactId>MyBatis</artifactId>  
    6.     <version>0.0.1-SNAPSHOT</version>  
    7.     <packaging>war</packaging>  
    8.   
    9.     <dependencies>  
    10.   
    11.         <dependency>  
    12.             <groupId>junit</groupId>  
    13.             <artifactId>junit</artifactId>  
    14.             <version>4.12</version>  
    15.             <scope>provided</scope>  
    16.         </dependency>  
    17.   
    18.         <dependency>  
    19.             <groupId>log4j</groupId>  
    20.             <artifactId>log4j</artifactId>  
    21.             <version>1.2.17</version>  
    22.         </dependency>  
    23.   
    24.         <dependency>  
    25.             <groupId>org.mybatis</groupId>  
    26.             <artifactId>mybatis</artifactId>  
    27.             <version>3.1.1</version>  
    28.         </dependency>  
    29.         <dependency>  
    30.             <groupId>mysql</groupId>  
    31.             <artifactId>mysql-connector-java</artifactId>  
    32.             <version>5.1.38</version>  
    33.         </dependency>  
    34.   
    35.     </dependencies>  
    36. </project>  
    37.   
    38. </span>  

     

    2.4、SqlMappingConfig.xml文件（看注释）

    [java] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE configuration  
    3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
    4. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
    5. <configuration>  
    6.   
    7.     <!-- 加载属性文件 -->  
    8.     <properties resource="db.properties">  
    9.         <!--properties中还可以配置一些属性名和属性值 -->  
    10.         <!-- <property name="jdbc.driver" value=""/> -->  
    11.     </properties>  
    12.   
    13.     <!-- 全局配置参数，需要时再设置 -->  
    14.     <!-- <settings> </settings> -->  
    15.   
    16.     <typeAliases>  
    17.         <!-- 别名定义 -->  
    18.         <!-- 针对单个别名定义 type：类型的路径 alias：别名 -->  
    19.         <!-- <typeAlias type="cn.czy.mybatis.po.User" alias="user"/> -->  
    20.         <typeAlias type="cn.com.czy.mybatis.pojo.User" alias="user" />  
    21.         <!-- 批量别名定义 指定包名，mybatis自动扫描包中的po类，自动定义别名，别名就是类名（首字母大写或小写都可以） -->  
    22.         <package name="cn.com.mybatis.mapper" />  
    23.     </typeAliases>  
    24.   
    25.     <!-- 和spring整合后 environments配置将废除 -->  
    26.     <environments default="development">  
    27.         <environment id="development">  
    28.             <!-- 使用jdbc事务管理，事务控制由mybatis -->  
    29.             <transactionManager type="JDBC" />  
    30.             <!-- 数据库连接池，由mybatis管理 -->  
    31.             <dataSource type="POOLED">  
    32.                 <property name="driver" value="${jdbc.driver}" />  
    33.                 <property name="url" value="${jdbc.url}" />  
    34.                 <property name="username" value="${jdbc.username}" />  
    35.                 <property name="password" value="${jdbc.password}" />  
    36.             </dataSource>  
    37.         </environment>  
    38.     </environments>  
    39.   
    40.   
    41.     <!-- 加载 映射文件 -->  
    42.     <mappers>  
    43.       
    44.       
    45.         <!--通过resource方法一次加载一个映射文件 -->  
    46.         <mapper resource="sqlMapper/user.xml" />  
    47.         <mapper resource="sqlMapper/userMapper.xml" />  
    48.         <mapper resource="sqlMapper/OrdersMapperCustom.xml"/>  
    49.   
    50.         <!-- 批量加载mapper 指定mapper接口的包名，mybatis自动扫描包下边所有mapper接口进行加载 -->  
    51.         <!-- 遵循一些规范：需要将mapper接口类名和mapper.xml映射文件名称保持一致，且在一个目录 -->  
    52.         <!-- 中 上边规范的前提是：使用的是mapper代理方法   
    53.         <package name="cn.com.czy.mybatis.two.mapper" />-->  
    54.           
    55.     </mappers>  
    56.   
    57. </configuration>  



    2.5、映射文件user.xml（注意在SqlMappingConfig.xml文件中已经引用它）

    [java] view plain copy
     
    1. <span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5.   
    6.   
    7. <!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离  -->  
    8. <!-- 注意：使用mapper代理方法开发，namespace有特殊重要的作用 -->  
    9. <mapper namespace="test">  
    10.   
    11.     <!-- 在 映射文件中配置很多sql语句 -->  
    12.     <!-- 将sql语句封装到mappedStatement对象中，所以将id称为statement的id -->  
    13.     <!-- parameterType：指定输入 参数的类型，这里指定int型 #{}表示一个占位符号 -->  
    14.     <!-- #{id}：其中的id表示接收输入 的参数，参数名称就是id，如果输入 -->  
    15.     <!-- 参数是简单类型，#{}中的参数名可以任意，可以value或其它名称 -->  
    16.     <!-- resultType：指定sql输出结果 的所映射的java对象类型，select指定resultType表示将单条记录映射成的java对象。 -->  
    17.     <select id="findUserById" parameterType="int"  
    18.         resultType="user">  
    19.         <!-- 需求：通过select执行id查询用户表的记录 -->  
    20.         SELECT * FROM USER WHERE id=#{value}  
    21.     </select>  
    22.   
    23.     <!-- resultType：指定就是单条记录所映射的java对象类型  -->  
    24.     <!-- ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接在sql中。 使用${}拼接sql，引起 sql注入  -->  
    25.     <!-- ${value}：接收输入 参数的内容，如果传入类型是简单类型，${}中只能使用value -->  
    26.     <!-- 这个mapper文件user对象已经用别名代替 -->  
    27.     <select id="findUserByName" parameterType="java.lang.String"  
    28.         resultType="user">  
    29.         <!-- 根据用户名称模糊查询用户信息，可能返回多条  -->  
    30.         SELECT * FROM USER WHERE username LIKE '%${value}%'  
    31.     </select>  
    32.   
    33.       
    34.     <!-- parameterType：指定输入 参数类型是pojo（包括 用户信息）-->   
    35.     <!-- #{}中指定pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值 -->  
    36.     <insert id="insertUser" parameterType="user">  
    37.         <!-- SELECT LAST_INSERT_ID()：得到刚insert进去记录的主键值，只适用与自增主键 -->  
    38.         <!-- keyProperty：将查询到主键值设置到parameterType指定的对象的哪个属性 -->  
    39.         <!-- order：SELECT LAST_INSERT_ID()执行顺序，相对于insert语句来说它的执行顺序 -->  
    40.         <!-- resultType：指定SELECT LAST_INSERT_ID()的结果类型 -->  
    41.         <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">  
    42.             <!-- 将插入数据的主键返回，返回到user对象中 -->  
    43.             SELECT LAST_INSERT_ID()  
    44.         </selectKey>  
    45.         insert into user(username,birthday,sex,address)  
    46.         value(#{username},#{birthday},#{sex},#{address})  
    47.         <!-- 使用mysql的uuid（）生成主键 执行过程： -->  
    48.         <!-- 首先通过uuid()得到主键，将主键设置到user对象的id属性中 其次在insert执行时，从user对象中取出id属性值 -->  
    49.         <!-- <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String"> -->  
    50.         <!-- SELECT uuid() </selectKey> insert into user(id,username,birthday,sex,address) -->  
    51.         <!-- value(#{id},#{username},#{birthday},#{sex},#{address}) -->  
    52.     </insert>  
    53.   
    54.   
    55.     <delete id="deleteUser" parameterType="java.lang.Integer">  
    56.         <!-- 删除 用户 根据id删除用户，需要输入 id值 -->  
    57.         delete from user where  
    58.         id=#{id}  
    59.     </delete>  
    60.   
    61.   
    62.     <!-- 需要传入用户的更新信息 parameterType指定user对象，包括 id和更新信息， -->  
    63.     <!-- 注意：id必须存在 -->  
    64.     <!-- #{id}：从输入 user对象中获取id属性值 -->  
    65.     <update id="updateUser" parameterType="user">  
    66.         <!-- 根据id更新用户 分析： 需要传入用户的id -->  
    67.         update user set  
    68.         username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}  
    69.         where id=#{id}  
    70.     </update>  
    71.   
    72. </mapper>  
    73.   
    74.   
    75. </span>  


    2.6、pojo类

    [java] view plain copy
     
    1. <span style="font-size:18px;">package cn.com.czy.mybatis.pojo;  
    2.   
    3. import java.util.Date;  
    4.   
    5.   
    6. /** 
    7.  *  
    8.  * <p>Title: User</p> 
    9.  * <p>Description:用户pojo </p> 
    10.  */  
    11. public class User {  
    12.       
    13.     //属性名和数据库表的字段对应  
    14.     private int id;  
    15.     private String username;    // 用户姓名  
    16.     private String sex;     // 性别  
    17.     private Date birthday;      // 生日  
    18.     private String address;     // 地址  
    19.       
    20.     public int getId() {  
    21.         return id;  
    22.     }  
    23.     public void setId(int id) {  
    24.         this.id = id;  
    25.     }  
    26.     public String getUsername() {  
    27.         return username;  
    28.     }  
    29.     public void setUsername(String username) {  
    30.         this.username = username;  
    31.     }  
    32.     public String getSex() {  
    33.         return sex;  
    34.     }  
    35.     public void setSex(String sex) {  
    36.         this.sex = sex;  
    37.     }  
    38.     public Date getBirthday() {  
    39.         return birthday;  
    40.     }  
    41.     public void setBirthday(Date birthday) {  
    42.         this.birthday = birthday;  
    43.     }  
    44.     public String getAddress() {  
    45.         return address;  
    46.     }  
    47.     public void setAddress(String address) {  
    48.         this.address = address;  
    49.     }  
    50.     @Override  
    51.     public String toString() {  
    52.         return "User [id=" + id + ", username=" + username + ", sex=" + sex  
    53.                 + ", birthday=" + birthday + ", address=" + address + "]";  
    54.     }  
    55.   
    56.   
    57. }  
    58. </span>  



    2.7、测试类(传统的不用接口、只是简单的)

    [java] view plain copy
     
    1. package cn.com.czy.mybatis.first;  
    2.   
    3. import java.io.IOException;  
    4. import java.io.InputStream;  
    5. import java.util.Date;  
    6. import java.util.List;  
    7.   
    8. import org.apache.ibatis.io.Resources;  
    9. import org.apache.ibatis.session.SqlSession;  
    10. import org.apache.ibatis.session.SqlSessionFactory;  
    11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
    12. import cn.com.czy.mybatis.pojo.User;  
    13. import org.junit.Test;  
    14.   
    15. /** 
    16.  * 《单表映射》 
    17.  * 入门程序总结：这是简单的mybatis入门程序 
    18.  * -- 1、映射(mapper)文件是user.xml --  --  
    19.  * -- 2、逻辑基本的resultType、parameterType等一下基础知识  --  --  
    20.  * -- 3、SqlSessionFactory、SqlSession的原理  --  --  
    21.  */  
    22. public class MybatisFirst {  
    23.   
    24.     public SqlSessionFactory getSqlSessionFactory() throws IOException {  
    25.         // mybatis配置文件  
    26.         String resource = "config/SqlMapConfig.xml";  
    27.         // 得到配置文件流  
    28.         InputStream inputStream = Resources.getResourceAsStream(resource);  
    29.         // 创建会话工厂，传入mybatis的配置文件信息  
    30.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
    31.         return sqlSessionFactory;  
    32.     }  
    33.   
    34.       
    35.   
    36.     // 根据id查询用户信息，得到一条记录结果  
    37.     @Test  
    38.     public void findUserByIdTest() throws IOException {  
    39.   
    40.         // 通过工厂得到SqlSession  
    41.         SqlSession sqlSession = this.getSqlSessionFactory().openSession();  
    42.   
    43.         // 通过SqlSession操作数据库  
    44.         // 第一个参数：映射文件中statement的id，等于=namespace+"."+statement的id  
    45.         // 第二个参数：指定和映射文件中所匹配的parameterType类型的参数  
    46.         // sqlSession.selectOne结果 是与映射文件中所匹配的resultType类型的对象  
    47.         // selectOne查询出一条记录  
    48.         User user = sqlSession.selectOne("test.findUserById", 1);  
    49.   
    50.         System.out.println(user);  
    51.   
    52.         // 释放资源  
    53.         sqlSession.close();  
    54.   
    55.     }  
    56.   
    57.     // 根据用户名称模糊查询用户列表  
    58.     @Test  
    59.     public void findUserByNameTest() throws IOException {  
    60.   
    61.         // 通过工厂得到SqlSession  
    62.         SqlSession sqlSession = this.getSqlSessionFactory().openSession();  
    63.         // list中的user和映射文件中resultType所指定的类型一致  
    64.         List<User> list = sqlSession.selectList("test.findUserByName", "小明");  
    65.         System.out.println("信息：" + list);  
    66.         sqlSession.close();  
    67.   
    68.     }  
    69.   
    70.     // 添加用户信息  
    71.     @Test  
    72.     public void insertUserTest() throws IOException {  
    73.   
    74.         // 通过工厂得到SqlSession  
    75.         SqlSession sqlSession = this.getSqlSessionFactory().openSession();  
    76.         // 插入用户对象  
    77.         User user = new User();  
    78.         user.setUsername("王小军");  
    79.         user.setBirthday(new Date());  
    80.         user.setSex("1");  
    81.         user.setAddress("河南郑州");  
    82.   
    83.         sqlSession.insert("test.insertUser", user);  
    84.   
    85.         // 提交事务  
    86.         sqlSession.commit();  
    87.   
    88.         // 获取用户信息主键  
    89.         System.out.println(user.getId());  
    90.         // 关闭会话  
    91.         sqlSession.close();  
    92.   
    93.     }  
    94.   
    95.     // 根据id删除 用户信息  
    96.     @Test  
    97.     public void deleteUserTest() throws IOException {  
    98.   
    99.         // 通过工厂得到SqlSession  
    100.         SqlSession sqlSession = this.getSqlSessionFactory().openSession();  
    101.   
    102.         // 传入id删除 用户  
    103.         sqlSession.delete("test.deleteUser", 49);  
    104.   
    105.         // 提交事务  
    106.         sqlSession.commit();  
    107.   
    108.         // 关闭会话  
    109.         sqlSession.close();  
    110.   
    111.     }  
    112.   
    113.     // 更新用户信息  
    114.     @Test  
    115.     public void updateUserTest() throws IOException {  
    116.   
    117.         // 通过工厂得到SqlSession  
    118.         SqlSession sqlSession = this.getSqlSessionFactory().openSession();  
    119.         // 更新用户信息  
    120.   
    121.         User user = new User();  
    122.         // 必须设置id  
    123.         user.setId(41);  
    124.         user.setUsername("王大军");  
    125.         user.setBirthday(new Date());  
    126.         user.setSex("2");  
    127.         user.setAddress("河南郑州");  
    128.   
    129.         sqlSession.update("test.updateUser", user);  
    130.   
    131.         // 提交事务  
    132.         sqlSession.commit();  
    133.   
    134.         // 关闭会话  
    135.         sqlSession.close();  
    136.   
    137.     }  
    138.   
    139. }  

     

     

    3.1、mapper代理方法来实现（实际开发用到的）

    1、pom.xml文件一样

    2、SqlMappingConfig.xml一样

    3、开发规范：编写

    3.2、接口UserMapping.xml文件（可能有点多、挑着看就好）

    （注意在SqlMappingConfig.xml文件中已经引用它）

    [java] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <!DOCTYPE mapper  
    3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
    4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
    5.   
    6.   
    7. <!-- mapper代理开发规范 -->  
    8. <!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离 -->  
    9. <!-- 注意：使用mapper代理方法开发，namespace有特殊重要的作用，namespace等于mapper接口地址 -->  
    10. <mapper namespace="cn.com.mybatis.mapper.UserMapper">  
    11.   
    12.     <!-- 定义sql片段 -->  
    13.     <!-- id：sql片段的唯 一标识 -->  
    14.     <!-- 经验：是基于单表来定义sql片段，这样话这个sql片段可重用性才高 在sql片段中不要包括 where -->  
    15.     <sql id="query_user_where">  
    16.         <if test="userCustom!=null">  
    17.             <if test="userCustom.sex!=null and userCustom.sex!=''">  
    18.                 and user.sex = #{userCustom.sex}  
    19.             </if>  
    20.             <if test="userCustom.username!=null and userCustom.username!=''">  
    21.                 and user.username LIKE '%${userCustom.username}%'  
    22.             </if>  
    23.         </if>  
    24.     </sql>  
    25.   
    26.     <!-- 已经指定好别名！ -->  
    27.     <!-- 运用sql片段   -->  
    28.     <!-- 用户信息综合查询 #{userCustom.sex}:取出pojo包装对象中性别值  -->  
    29.     <!-- ${userCustom.username}：取出pojo包装对象中用户名称 -->  
    30.     <select id="findUserList" parameterType="UserQueryVo"  
    31.         resultType="UserCustom">  
    32.         SELECT * FROM USER  
    33.         <!-- where可以自动去掉条件中的第一个and -->  
    34.         <where>  
    35.             <!-- 引用sql片段 的id，如果refid指定的id不在本mapper文件中，需要前边加namespace -->  
    36.             <include refid="query_user_where"></include>  
    37.             <!-- 在这里还要引用其它的sql片段 -->  
    38.         </where>  
    39.     </select>  
    40.   
    41.     <!-- 用户信息综合查询总数 parameterType：指定输入类型和findUserList一样 resultType：输出结果类型 -->  
    42.     <select id="findUserCount" parameterType="UserQueryVo"  
    43.         resultType="int">  
    44.         SELECT count(*) FROM USER  
    45.         <!-- where可以自动去掉条件中的第一个and -->  
    46.         <where>  
    47.             <!-- 引用sql片段 的id，如果refid指定的id不在本mapper文件中，需要前边加namespace -->  
    48.             <include refid="query_user_where"></include>  
    49.             <!-- 在这里还要引用其它的sql片段 -->  
    50.         </where>  
    51.     </select>  
    52.   
    53.     <!-- 在 映射文件中配置很多sql语句 -->  
    54.     <!-- 需求：通过id查询用户表的记录 -->  
    55.     <!-- 通过 select执行数据库查询 -->  
    56.     <!-- id：标识 映射文件中的 sql -->  
    57.     <!-- 将sql语句封装到mappedStatement对象中，所以将id称为statement的id -->  
    58.     <!-- parameterType：指定输入 参数的类型，这里指定int型 -->  
    59.     <!-- #{}表示一个占位符号 -->  
    60.     <!-- #{id}：其中的id表示接收输入 的参数，参数名称就是id，如果输入 参数是简单类型，#{}中的参数名可以任意，可以value或其它名称 -->  
    61.     <!-- resultType：指定sql输出结果 的所映射的java对象类型，select指定resultType表示将单条记录映射成的java对象。 -->  
    62.     <!-- mapper开发代理规范2:UserMapper 接口中的接口方法名跟id名一样 -->  
    63.     <!-- mapper开发代理规范3:UserMapper 接口中的返回类型名跟resultType类型一样 -->  
    64.     <!-- mapper开发代理规范 4:UserMapper 接口中的参数类型名跟parameterType类型一样 -->  
    65.     <select id="findUserById" parameterType="int" resultType="user">  
    66.         SELECT * FROM USER WHERE id=#{value}  
    67.     </select>  
    68.   
    69.     <!-- 根据用户名称模糊查询用户信息，可能返回多条 resultType：指定就是单条记录所映射的java对象 类型 ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接在sql中。   
    70.         使用${}拼接sql，引起 sql注入 ${value}：接收输入 参数的内容，如果传入类型是简单类型，${}中只能使用value -->  
    71.     <select id="findUserByName" parameterType="java.lang.String"  
    72.         resultType="user">  
    73.         SELECT * FROM USER WHERE username LIKE '%${value}%'  
    74.     </select>  
    75.   
    76.   
    77.   
    78.     <!-- 定义resultMap -->  
    79.     <!-- 将SELECT id id_,username username_ FROM USER 和User类中的属性作一个映射关系 -->  
    80.     <!-- type：resultMap最终映射的java对象类型,可以使用别名 -->  
    81.     <!-- id：对resultMap的唯一标识 -->  
    82.     <resultMap type="user" id="userResultMap">  
    83.         <!--id表示查询结果集中唯一标识 -->  
    84.         <!--column：查询出来的列名 -->  
    85.         <!--property：type指定的pojo类型中的属性名 最终resultMap对column和property作一个映射关系 （对应关系） -->  
    86.         <id column="id_" property="id" />  
    87.         <!--result：对普通名映射定义 -->  
    88.         <!--column：查询出来的列名 -->  
    89.         <!--property：type指定的pojo类型中的属性名 最终resultMap对column和property作一个映射关系 （对应关系） -->  
    90.         <result column="username_" property="username" />  
    91.     </resultMap>  
    92.   
    93.     <!-- 使用resultMap进行输出映射 -->  
    94.     <!--resultMap：指定定义的resultMap的id，如果这个resultMap在其它的mapper文件，前边需要加namespace -->  
    95.     <select id="findUserByIdResultMap" parameterType="int"  
    96.         resultMap="userResultMap">  
    97.         SELECT id id_,username username_ FROM USER WHERE id=#{value}  
    98.     </select>  
    99.   
    100.   
    101. </mapper>  


    3.3、UserMapping.java类

    [java] view plain copy
     
    1. package cn.com.mybatis.mapper;  
    2.   
    3. import java.util.List;  
    4.   
    5. import cn.com.czy.mybatis.pojo.User;  
    6.   
    7. /** 
    8.  * 总结： 
    9.  * 1、mapper代理方式、理解mapper开发规范  
    10.  * 2、mapper文件是usermapper.xml 
    11.  * 3、了解动态sql、别名、sql代码片、 
    12.  * 4、了解  resultMap 
    13.  *  
    14.  * <p> 
    15.  * Title: UserMapper 
    16.  * </p> 
    17.  * <p> 
    18.  * Description: mapper接口，相当 于dao接口，用户管理 
    19.  * </p> 
    20.  */  
    21. public interface UserMapper {  
    22.   
    23.     // 根据id查询用户信息  
    24.     public User findUserById(int id) throws Exception;  
    25.   
    26.     // 根据用户名列查询用户列表  
    27.     public List<User> findUserByName(String name) throws Exception;  
    28.   
    29.     // 根据id查询用户信息，使用resultMap输出  
    30.     public User findUserByIdResultMap(int id) throws Exception;  
    31.   
    32.     // 用户信息综合查询  
    33.     public List<UserCustom> findUserList(UserQueryVo userQueryVo) throws Exception;  
    34.   
    35.     // 用户信息综合查询总数  
    36.     public int findUserCount(UserQueryVo userQueryVo) throws Exception;  
    37.   
    38.     // 插入用户  
    39.     public void insertUser(User user) throws Exception;  
    40.   
    41.     // 删除用户  
    42.     public void deleteUser(int id) throws Exception;  
    43.   
    44. }  

    3.3、包装类、继承类（这些只是为了以后更好的拓展罢了）

    UserMapping的子类

    [java] view plain copy
     
    1. package cn.com.mybatis.mapper;  
    2.   
    3. import cn.com.czy.mybatis.pojo.User;  
    4.   
    5. /** 
    6.  * 总结： 
    7.  * 1、mapper代理方式、理解mapper开发规范  
    8.  * 2、mapper文件是usermapper.xml 
    9.  * 3、了解动态sql、别名、sql代码片、 
    10.  * 4、了解  resultMap 
    11.  *  
    12.  * <p>Title: UserCustom</p> 
    13.  * <p>Description: 用户的扩展类</p> 
    14.  */  
    15. public class UserCustom extends User{  
    16.       
    17.     //可以扩展用户的信息  
    18.   
    19. }  

    UserMapping的包装类

    [java] view plain copy
     
    1. package cn.com.mybatis.mapper;  
    2.   
    3.   
    4. /** 
    5.  * 总结： 
    6.  * 1、mapper代理方式、理解mapper开发规范  
    7.  * 2、mapper文件是usermapper.xml 
    8.  * 3、了解动态sql、别名、sql代码片、 
    9.  * 4、了解  resultMap 
    10.  *  
    11.  * <p>Title: UserQueryVo</p> 
    12.  * <p>Description:包装类型 </p> 
    13.  */  
    14. public class UserQueryVo {  
    15.       
    16.       
    17.     //在这里包装所需要的查询条件  
    18.       
    19.     //用户查询条件  
    20.     private UserCustom userCustom;  
    21.   
    22.     public UserCustom getUserCustom() {  
    23.         return userCustom;  
    24.     }  
    25.   
    26.     public void setUserCustom(UserCustom userCustom) {  
    27.         this.userCustom = userCustom;  
    28.     }  
    29.   
    30.     //可以包装其它的查询条件，订单、商品  
    31.     //....  
    32. }  

    3.5测试类

    [java] view plain copy
     
    1. package cn.com.mybatis.mapper;  
    2.   
    3. import java.io.InputStream;  
    4. import java.util.List;  
    5.   
    6. import org.apache.ibatis.io.Resources;  
    7. import org.apache.ibatis.session.SqlSession;  
    8. import org.apache.ibatis.session.SqlSessionFactory;  
    9. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
    10. import org.junit.Before;  
    11. import org.junit.Test;  
    12.   
    13. import cn.com.czy.mybatis.pojo.User;  
    14.   
    15. /* 
    16.  *  
    17.  * 总结： 
    18.  * 1、mapper代理方式、理解mapper开发规范  
    19.  * 2、mapper文件是usermapper.xml 
    20.  * 3、了解动态sql、别名、sql代码片、 
    21.  * 4、了解  resultMap 
    22.  * 
    23.  */  
    24. public class UserMapperTest {  
    25.   
    26.     private SqlSessionFactory sqlSessionFactory;  
    27.   
    28.     // 此方法是在执行testFindUserById之前执行  
    29.     @Before  
    30.     public void setUp() throws Exception {  
    31.   
    32.         // mybatis配置文件  
    33.         String resource = "config/SqlMapConfig.xml";  
    34.         // 得到配置文件流  
    35.         InputStream inputStream = Resources.getResourceAsStream(resource);  
    36.   
    37.         // 创建会话工厂，传入mybatis的配置文件信息  
    38.         sqlSessionFactory = new SqlSessionFactoryBuilder()  
    39.                 .build(inputStream);  
    40.     }  
    41.   
    42.     //用户信息的综合 查询  
    43.     @Test  
    44.     public void testFindUserList() throws Exception {  
    45.           
    46.         SqlSession sqlSession = sqlSessionFactory.openSession();  
    47.           
    48.         //创建UserMapper对象，mybatis自动生成mapper代理对象  
    49.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
    50.           
    51.         //创建包装对象，设置查询条件  
    52.         UserQueryVo userQueryVo = new UserQueryVo();  
    53.         UserCustom userCustom = new UserCustom();  
    54.         userCustom.setSex("1");  
    55.         userCustom.setUsername("郑游");  
    56.         userQueryVo.setUserCustom(userCustom);  
    57.           
    58.         //调用userMapper的方法  
    59.         List<UserCustom> list = userMapper.findUserList(userQueryVo);  
    60.           
    61.         System.out.println(list);  
    62.     }  
    63.       
    64.       
    65.       
    66.     @Test  
    67.     public void testFindUserCount() throws Exception {  
    68.           
    69.         SqlSession sqlSession = sqlSessionFactory.openSession();  
    70.           
    71.         //创建UserMapper对象，mybatis自动生成mapper代理对象  
    72.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
    73.           
    74.         //创建包装对象，设置查询条件  
    75.         UserQueryVo userQueryVo = new UserQueryVo();  
    76.         UserCustom userCustom = new UserCustom();  
    77.         userCustom.setSex("1");  
    78.         userCustom.setUsername("郑游");  
    79.         userQueryVo.setUserCustom(userCustom);  
    80.         //调用userMapper的方法  
    81.         int count = userMapper.findUserCount(userQueryVo);  
    82.           
    83.         System.out.println(count);  
    84.     }  
    85.       
    86.       
    87.       
    88.     @Test  
    89.     public void testFindUserById() throws Exception {  
    90.           
    91.         SqlSession sqlSession = sqlSessionFactory.openSession();  
    92.           
    93.         //创建UserMapper对象，mybatis自动生成mapper代理对象  
    94.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
    95.           
    96.         //调用userMapper的方法  
    97.           
    98.         User user = userMapper.findUserById(1);  
    99.           
    100.         System.out.println(user);  
    101.           
    102.           
    103.     }  
    104.       
    105.       
    106.     @Test  
    107.     public void testFindUserByName() throws Exception {  
    108.           
    109.         SqlSession sqlSession = sqlSessionFactory.openSession();  
    110.           
    111.         //创建UserMapper对象，mybatis自动生成mapper代理对象  
    112.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
    113.           
    114.         //调用userMapper的方法  
    115.           
    116.         List<User> list = userMapper.findUserByName("小明");  
    117.           
    118.         sqlSession.close();  
    119.           
    120.         System.out.println(list);  
    121.           
    122.           
    123.     }  
    124.       
    125.     @Test  
    126.     public void testFindUserByIdResultMap() throws Exception {  
    127.           
    128.         SqlSession sqlSession = sqlSessionFactory.openSession();  
    129.           
    130.         //创建UserMapper对象，mybatis自动生成mapper代理对象  
    131.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
    132.           
    133.         //调用userMapper的方法  
    134.           
    135.         User user = userMapper.findUserByIdResultMap(1);  
    136.           
    137.         System.out.println(user);  
    138.           
    139.     }  
    140.   
    141. }  


     

    推荐教程

         Maven官方中文教程

         Mybatis的mapper.xml文件详解

         SSM框架教程
  • 相关阅读:
    三大流程控制：1、if判断语句 2、while循环语句 3、for循环语句
    变量剩余的部分，然后是基本数据类型、输入输出和基本运算符
    1.操作系统、2.编程语言分类、3.变量、4.运行python文件的三个阶段
    数据库4 待修
    电脑组合键
    redis 基础应用
    数据库3 待改
    数据库2 待修
    mysql 数据库基础篇
    socketserver 和 事件Event
  • 原文地址：https://www.cnblogs.com/DreamRecorder/p/9100659.html
Copyright © 2011-2022 走看看