Spring+SpringMVC+MyBatis-教程、笔记-10

最新推荐文章于 2023-10-14 22:00:52 发布

夏天的冬雪

最新推荐文章于 2023-10-14 22:00:52 发布

阅读量182

点赞数

分类专栏： Spring+SpringMVC+MyBatis-教程-笔记文章标签： spring mybatis 笔记

本文链接：https://blog.youkuaiyun.com/qq_48269763/article/details/132007246

版权

Spring+SpringMVC+MyBatis-教程-笔记专栏收录该内容

11 篇文章

订阅专栏

base黑马，视频链接：https://www.bilibili.com/video/BV1WZ4y1P7Bp?t=94.4
此系列文章可以当做视频的配套笔记，也可以当做自学SSM框架的教程。

mybatis简介-原始jdbc简介

为什么不把resultSet这个结果集直接返回给业务层呢？
因为在一般的程序开发中，层与层之间的数据传递都是通过实体，也就是POJO对象，也可以叫做JavaBean。

上面这段代码是dao层的代码。
原始jdbc操作时，查询数据和插入数据的很多代码都是结构化的，也就是很多代码都是模板代码。
其中变化的代码主要就是sql语句。

原始jdbc缺点：
1、插入操作、查询操作有很多重复代码。
2、每个用户在进行操作时，都要创建connection等对象，这样就导致资源如果用，就创建，用完资源就关闭，这样是特别消耗程序性能的。
3、SQL语句，叫做结构化查询语言，SQL语句之外的都是Java代码，这就导致SQL语句和java代码耦合死了。

mybatis快速入门-mybatis概述

mybatis快速入门-代码实现

映射文件与核心文件的名字实际上叫什么都无所谓，但一般的命名规则是上面的写法。
映射文件内部主要写的是sql语句，核心文件主要配置一些mybatis这个框架的核心配置。

创建user数据表：

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(10) DEFAULT NULL,
  `password` varchar(13) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'zhansan', '1234');
INSERT INTO `user` VALUES ('2', 'lisi', '3434');
INSERT INTO `user` VALUES ('3', 'wangwu', '3445');

pom.xml文件中引入相应的坐标：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lyh</groupId>
  <artifactId>spring_demo_01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring_demo_01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <!--不管是什么dao层的框架，最终都要与mysql打交道-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>
    <!--引入mybatis的坐标-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>
    <!--测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!--日志-->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>
</project>

在com.lyh.domain包下创建User类，和数据库中的user表相对应。
编写User实体类：

package com.lyh.domain;

public class User {
    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //方便测试，写上toString()方法
    @Override
    public String toString() {
        return "User{" +
            "id=" + id +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            '}';
    }
}

映射文件UserMapper.xml是在resources文件夹下面，一般情况下，映射文件的包是和实体的包或者和dao层的包是在一起的。
创建UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--mapper文件约束头，用的是dtd约束-->
<!--相应的配置-->
<!--给当前文件一个命名空间-->
<mapper namespace="userMapper">
  <!--在调用select语句时，先找到userMapper再找到findAll-->
  <!--resultType="com.lyh.domain.User"：代表查询到结果集之后，往User对象内部封装-->
  <select id="findAll" resultType="com.lyh.domain.User">
    select * from user
  </select>

</mapper>

在resources目录下创建，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>
  <!--配置数据源的环境-->
  <!--default="development"：environments里面可以配置很多环境，说明一个默认的环境  -->
  <environments default="development">
    <environment id="development">
      <!--transactionManager：事务管理器，这里用的是原生JDBC的事务管理器-->
      <transactionManager type="JDBC"></transactionManager>
      <!--数据源的类型：池化思想的，池子-->
      <!--配置好数据源了，意味着mybatis在进行数据库操作时，
      会从指定的数据源中，获得一个connection进行操作，
      操作完之后会把connection归还-->
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/test"/>
        <property name="username" value="root"/>
        <property name="password" value="1234"/>
      </dataSource>
    </environment>
  </environments>
  
	<!--加载映射文件-->
    <mappers>
        <mapper resource="com/lyh/mapper/UserMapper.xml"/>
    </mappers>
  
</configuration>

创建测试类：MybatisTest

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
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 org.junit.Test;

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

public class MybatisTest {
    @Test
    public void test1() throws IOException {
        //加载核心配置文件
        //找的是相对地址，相对类加载路径下。当前的核心文件就在，类加载路径下
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        //获得SqlSessionFactory工厂对象   在build时把resourceAsStream输入流给它
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得session会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行操作
        //是有很多数据，返回的是很多对象的一个集合
        //参数：namespace+id
        List<User> userList = sqlSession.selectList("userMapper.findAll");
        //打印数据
        System.out.println(userList);
        //释放资源
        sqlSession.close();

    }
}

测试效果：

mybatis映射文件概述

映射文件DTD约束头：有了约束头后，下面再写一些标签或者属性时，就可以给出提示，起到约束与提示的作用。

mybatis的增删改查-插入数据操作

UserMapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="userMapper">
  <!--插入操作-->
  <!-- parameterType="com.lyh.domain.User"：将User对象属性的值，设置到 values(......)中-->
  <!-- #{id}：id就是User类中的属性名id，这个id对应表中的字段id   -->
  <insert id="save" parameterType="com.lyh.domain.User">
    insert into user values (#{id},#{username},#{password})
  </insert>


</mapper>

MybatisTest类：

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
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 org.junit.Test;

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

public class MybatisTest {

    @Test
    public void test2() throws IOException {
        //模拟User对象
        User user = new User();
        //user.setId(9);//这个id不设置也是可以的 因为表中的id字段是自增的
        user.setUsername("Andy");
        user.setPassword("7758521");
        
        //加载核心配置文件
        //找的是一个相对地址，相对类加载路径下。当前的核心文件就在，类加载路径下
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        //获得SqlSessionFactory工厂对象   在build时把resourceAsStream输入流给它
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得session会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行操作
        //参数：namespace+id
        int insert = sqlSession.insert("userMapper.save",user);
        
        //查询操作不会对表产生影响，没有用到事务
        //mybatis默认事务 是 不提交的，
        //所以没有 “sqlSession.commit();” 这行代码 插入操作是不生效的
        //mybatis执行更新操作时，需要提交事务，只有提交了事务，数据才会正真地持久化到数据库中
        sqlSession.commit();
        System.out.println(insert);
        //释放资源
        sqlSession.close();
    }
}

tip：

事务虽然没有提交但sql已经发出去了，数据没有存到数据库中，但是数据库中的id已经发生了自增

效果：

mybatis的增删改查-插入数据注意点

mybatis的增删改查-修改和删除操作

修改操作：
UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="userMapper">
  <!--修改操作-->
  <!--修改是根据id去修改其他的字段 parameterType同样是"com.lyh.domain.User"-->
  <update id="update" parameterType="com.lyh.domain.User">
    update user set username=#{username},password=#{password} where id=#{id}
  </update>
</mapper>

MybatisTest类：

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
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 org.junit.Test;

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

public class MybatisTest {

    //修改操作
    @Test
    public void test3() throws IOException {
        //模拟User对象
        User user = new User();
        user.setId(4);  //进行相应修改时，根据id进行相应的修改
        user.setUsername("Lucy");
        user.setPassword("abcd");
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        //获得SqlSessionFactory工厂对象   在build时把resourceAsStream输入流给它
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得session会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行操作
        //参数：namespace+id
        sqlSession.update("userMapper.update",user);
        //mybatis执行更新操作，需要提交事务，只有提交了事务，数据库中的数据才会正真的发生变化
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    }
    
}

删除操作：
UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="userMapper">
  <!--删除操作-->
  <!--删除的时候是根据id删除的 id是int类型-->
  <!--当只传递了一个参数并且是一个简单类型，id=#{id}，{}中实际上写什么都可以-->
  <!--为了可读性好一点，{}中写id-->
  <delete id="delete" parameterType="java.lang.Integer">
    delete from user where id=#{id}
  </delete>
</mapper>

MybatisTest类：

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
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 org.junit.Test;

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

public class MybatisTest {
    
    //删除操作
    @Test
    public void test4() throws IOException {

        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        //获得SqlSessionFactory工厂对象   在build时把resourceAsStream输入流给它
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得session会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行操作
        //参数：namespace+id
        sqlSession.delete("userMapper.delete",4);
        //mybatis执行更新操作，需要提交事务，只有提交了事务，数据库中的数据才会正真的发生变化
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    	}
    }

mybatis的增删改查-知识小结

查询数据：如果在查询时，是根据条件查询的，意味着查询的时候不仅有结果类型resultType，还要有参数类型parameterType。

mybatis核心配置文件-概述

mybatis核心配置文件-environments标签

JDBC：如果写的是JDBC，事务的操作通过的就是从数据源中拿到的connection进行操作，之前手动控制事务比较多，现在默认情况下是mybatis帮我进行事务控制。
MANAGED：这个用的并不是很多，这个事务的管理并不是通过原始的connection，而是通过容器去管理。
UNPOOLED：不使用连接池，底层的操作就像原始的JDBC操作一样，用的时候就创建一个connection，用完之后，就把connection进行相应的关闭。没有进行相应的优化。相对而言使用POOLED。
JNDI：略

mybatis核心配置文件-mappers标签

第一种：

第四种：就是使用包的。

mybatis核心配置文件-properties标签

在resources目录下创建 jdbc.properties 文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=1234

resources目录下的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>
  
  <!--通过properties加载外部properties文件-->
  <properties resource="jdbc.properties"/>
  
  <!--配置数据源的环境-->
  <environments default="development">
    <environment id="development">
      <!--transactionManager：事务管理器，这里用的是原生JDBC的事务管理器-->
      <transactionManager type="JDBC"></transactionManager>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>
  
  <!--加载映射文件-->
  <mappers>
    <mapper resource="com/lyh/mapper/UserMapper.xml"/>
  </mappers>
  
</configuration>

效果：也是可以通过测试的。

mybatis核心配置文件-typeAliases标签

mybatis框架设置好的一些常用的类型的别名：

UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="userMapper">
  
  <!--    为什么 parameterType="int" 也是可以的？
  因为mybatis已经把一些常用的类型都已经定义好别名了-->
  <delete id="delete" parameterType="int">
    delete from user where id=#{id}
  </delete>
  
  <select id="findAll" resultType="user">
    select * from user
  </select>
  <!--    <select id="findAll" resultType="com.lyh.domain.User">-->
  <!--        select * from user-->
  <!--    </select>-->

</mapper>

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>
  <!--    通过properties加载外部properties文件-->
  <properties resource="jdbc.properties"/>

  <!--    配置数据源的环境-->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"></transactionManager>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>
  
  <!--    加载映射文件-->
  <mappers>
    <mapper resource="com/lyh/mapper/UserMapper.xml"/>
  </mappers>

  <!--注意！！！自定义别名在这个位置会报错 出现以下的错误-->
  <!--自定义别名 为com.lyh.domain.User 定义别名为 user-->
  <typeAliases>
    <typeAlias type="com.lyh.domain.User" alias="user"/>
  </typeAliases>
  
</configuration>

上面报错提示，configuration中的属性得按照提示给出的顺序排列。
所以改变属性顺序的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>
  <!--    通过properties加载外部properties文件-->
  <properties resource="jdbc.properties"/>
  
  <!--自定义别名 为com.lyh.domain.User 定义别名为 user-->
  <typeAliases>
    <typeAlias type="com.lyh.domain.User" alias="user"/>
  </typeAliases>

  <!--    配置数据源的环境-->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"></transactionManager>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>
  
  <!--    加载映射文件-->
  <mappers>
    <mapper resource="com/lyh/mapper/UserMapper.xml"/>
  </mappers>
  
</configuration>

效果：可以运行

mybatis核心配置文件-知识小结

mybatis相应API

SqlSessionFactory build(InputStream inputStream)：
帮我去构建一个session工程，主要用的API就是build方法，Builder对象直接new就行，要想去获得一个工厂对象，需要调用build方法，当调用build方法时，方法内要有个参数，这个参数就是mybatis核心文件的输入流。这个流可以是字节或字符。最终返回的就是SqlSessionFactory对象。

String resources = “xx/xx/xx/xx.xml”：
这个地址是相对于类加载路径的，如果是maven工程，就是相对于resources目录的

与数据库交互的这些API都在SqlSession这个会话对象内部封装。
所以得一步一步的最终去获得SqlSession对象。

根据id查询一个对象数据
UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="userMapper">
 
  <!--    根据id进行查询            											别名-->
  <select id="findById" parameterType="int" resultType="user">
    select * from user where id=#{id}
  </select>

</mapper>

MybatisTest类

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
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 org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    
    //根据id 查询一个 对象数据
    @Test
    public void test1_1() throws IOException {
        //加载核心配置文件
        //这里找的是一个相对地址，相对类加载路径下
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        //获得SqlSessionFactory工厂对象   在build时把resourceAsStream输入流给它
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得session会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行操作
        //参数：namespace+id
        User user = sqlSession.selectOne("userMapper.findById", 3);
        //打印数据
        System.out.println(user);
        //释放资源
        sqlSession.close();
    }

}

效果：

mybatis的dao层实现-传统实现方式

pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lyh</groupId>
  <artifactId>spring_demo_01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring_demo_01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>
</project>

UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="userMapper">
  <!--        查询操作-->
  <select id="findAll" resultType="user">
    select * from user
  </select>

</mapper>

jdbc.properties文件：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=1234

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>
  <!--    通过properties加载外部properties文件-->
  <properties resource="jdbc.properties"/>

  <!--    自定义别名 -->
  <typeAliases>
    <typeAlias type="com.lyh.domain.User" alias="user"/>
  </typeAliases>

  <!--    数据源环境-->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"></transactionManager>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>

  <!--加载映射文件-->
  <mappers>
    <mapper resource="com/lyh/mapper/UserMapper.xml"/>
  </mappers>


</configuration>

实体类：User

package com.lyh.domain;

public class User {
    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //方便测试，写上toString()方法
    @Override
    public String toString() {
        return "User{" +
            "id=" + id +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            '}';
    }
}

dao层：
接口：UserMapper

package com.lyh.dao;

import com.lyh.domain.User;

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

public interface UserMapper {
    public List<User> findAll() throws IOException;
}

实现类：UserMapperImpl

package com.lyh.dao.impl;

import com.lyh.dao.UserMapper;
import com.lyh.domain.User;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserMapperImpl implements UserMapper {
    @Override
    public List<User> findAll() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> userList = sqlSession.selectList("userMapper.findAll");
        return userList;
    }
}

service层：以单元测试的方式去模拟
ServiceDemo类：

package com.lyh.service;

import com.lyh.dao.UserMapper;
import com.lyh.dao.impl.UserMapperImpl;
import com.lyh.domain.User;
import java.io.IOException;
import java.util.List;

//service层 以单元测试的方式去模拟
public class ServiceDemo {
    public static void main(String[] args) throws IOException {
        //业务层要获得dao层的
        //创建dao层对象  当前dao层实现是手动编写的
        UserMapper userMapper = new UserMapperImpl();
        List<User> userList = userMapper.findAll();
        System.out.println(userList);
    }
}

效果：

mybatis的dao层实现-接口代理方式实现规范

代理对象可以认为就是要操作的实现对象。
调用的时候会动态的去调用根据接口生成的代理对象。

通过 sqlSession.getMapper(UserMapper.class)，来获得接口的实现对象

mybatis的dao层实现-接口代理方式代码实现

删除dao层的impl包

接口：UserMapper

package com.lyh.dao;

import com.lyh.domain.User;
import java.io.IOException;
import java.util.List;

public interface UserMapper {
    public List<User> findAll() throws IOException;
    public User findById(int id);
}

UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--namespace为UserMapper接口的全限定名-->
<mapper namespace="com.lyh.dao.UserMapper">
  <!--  查询操作  id名要与接口中的方法名字一致-->
  <select id="findAll" resultType="user">
    select * from user
  </select>

  <!--    根据id进行查询-->
  <select id="findById" parameterType="int" resultType="user">
    select * from user where id = #{id}
  </select>

</mapper>

ServiceDemo类

package com.lyh.service;

import com.lyh.dao.UserMapper;
import com.lyh.domain.User;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

//service层 以单元测试的方式去模拟
public class ServiceDemo {
    public static void main(String[] args) throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> all = userMapper.findAll();
        System.out.println(all);
        System.out.println("==========");
        User user = userMapper.findById(3);
        System.out.println(user);
    }
}

效果：

mybatis的dao层实现-知识小结

mybatis映射文件深入-动态sql概述和环境搭建

目录结构：

pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lyh</groupId>
  <artifactId>spring_demo_01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring_demo_01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>
</project>

实体类：User

package com.lyh.domain;

public class User {
    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //方便测试，写上toString()方法
    @Override
    public String toString() {
        return "User{" +
            "id=" + id +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            '}';
    }
}

接口：UserMapper

package com.lyh.mapper;

import com.lyh.domain.User;
import java.util.List;

public interface UserMapper {
    public List<User> findByCondition(User user);

}

UserMapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lyh.mapper.UserMapper">
  <select id="findByCondition" parameterType="user" resultType="user">
    select * from user where id=#{id} and username=#{username} and password=#{password}
  </select>
</mapper>

jdbc.properties文件：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=1234

log4j.properties文件：

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:/mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
### 级别是信息级别的info 改为debug ###
log4j.rootLogger=debug, stdout

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>
  <!--    通过properties加载外部properties文件-->
  <properties resource="jdbc.properties"/>

  <!--    自定义别名 -->
  <typeAliases>
    <typeAlias type="com.lyh.domain.User" alias="user"/>
  </typeAliases>

  <!--    数据源环境-->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"></transactionManager>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>

  <!--    加载映射文件-->
  <mappers>
    <mapper resource="com/lyh/mapper/UserMapper.xml"/>
  </mappers>


</configuration>

测试类：MapperTest

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

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

public class MapperTest {

    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //模拟条件user
        User condition = new User();
        condition.setId(1);
        condition.setUsername("zhansan");
        condition.setPassword("1234");

        List<User> userList = userMapper.findByCondition(condition);

        System.out.println(userList);
    }

}

效果：

mybatis映射文件深入-动态sql-if

UserMapper.xml文件写法1：

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <mapper namespace="com.lyh.mapper.UserMapper">
        <select id="findByCondition" parameterType="user" resultType="user">
    
            	select * from user where 1=1
            <if test="id!=0">
            	and id=#{id}
            </if>
            <if test="username!=null">
            	and username=#{username}
            </if>
            <if test="password!=null">
            	and password=#{password}
            </if>
                
        </select>
    </mapper>

where 1=1 是为了方便拼接
test后面是判断条件

MapperTest类：只根据username条件查询

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

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

public class MapperTest {

    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //模拟条件user
        //根据条件查询用户信息的条件是不能确定的，
        //有时候是1个条件，有时候是两个条件......
        User condition = new User();
        //condition.setId(1);
        condition.setUsername("zhansan");
        //业务：如果没有password，意味着password是什么都可以
        //根据查询条件的不同，导致查询语句也不同
        //condition.setPassword("1234");

        List<User> userList = userMapper.findByCondition(condition);

        System.out.println(userList);
    }

}

效果：

UserMapper.xml文件写法2：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lyh.mapper.UserMapper">
  <select id="findByCondition" parameterType="user" resultType="user">

    select * from user 
      <where>
        <if test="id!=0">
          and id=#{id}
        </if>
        <if test="username!=null">
          and username=#{username}
        </if>
        <if test="password!=null">
          and password=#{password}
        </if>
      </where>
  </select>
</mapper>

会根据条件是否满足，来动态的决定是否拼接上where关键字。

MapperTest类：只根据username和password条件进行查询

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

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

public class MapperTest {

    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //模拟条件user
        //根据条件查询，用户信息的条件是不能确定的
        //有时候是1个条件，有时候是两个条件......
        User condition = new User();
        //condition.setId(1);
        condition.setUsername("zhansan");
        //业务：如果没有password，意味着password是什么都可以
        //根据查询条件的不同，导致查询语句也不同
        condition.setPassword("1234");

        List<User> userList = userMapper.findByCondition(condition);

        System.out.println(userList);
    }

}

效果：

mybatis映射文件深入-动态sql-foreach

collection就是集合
应用场景：可以查询id等于1的或者id等于2的或者id等于3的
select * from user where id =1 or id=2 or id =6
select * FROM user where id in(1,2,3)
括号中的 1,2,3 会改变

接口：UserMapper

package com.lyh.mapper;

import com.lyh.domain.User;
import java.util.List;

public interface UserMapper {
    //                传递给的参数不是一个数值，是很多个数值
    public List<User> findByIds(List<Integer> ids);
}

UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lyh.mapper.UserMapper">
  
  <!--参数是一个集合，返回值是一个user-->
  <!--collection是集合，如果传递的参数是list的话，参数就是list，如果传递的是数组的话，就是array-->
  <!--open="id in("，表示以 “id in(” 开始 -->
  <!--close=")"，表示以 “)” 结束-->
  <!--separator=","，表示数值的中间以“,” 分隔拼接-->
  <!--item="id"，item表示项，" "中可以随便写一个变量，这里写id，id变量负责去接收collection集合中的每一个值-->
  <!--<foreach>......</foreach> 内部写对应的每一个数值，也就是list集合中的多个id-->
  <select id="findByIds" parameterType="list" resultType="user">
    select * from user
    <where>
      <foreach collection="list" open="id in(" close=")" item="id" separator=",">
        #{id}
      </foreach>
    </where>
  </select>
    
</mapper>

测试类：MapperTest

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class MapperTest {

    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //模拟ids的数据
        List<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(2);
        ids.add(4);
        List<User> userList = userMapper.findByIds(ids);
        System.out.println(userList);

    }

}

效果：

mybatis映射文件深入-动态sql-sql片段的抽取

UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lyh.mapper.UserMapper">
  <sql id="selectUser">select * from user</sql>
  <select id="findByCondition" parameterType="user" resultType="user">
    <include refid="selectUser"></include>
    <where>
      <if test="id!=0">
        and id=#{id}
      </if>
      <if test="username!=null">
        and username=#{username}
      </if>
      <if test="password!=null">
        and password=#{password}
      </if>
    </where>
  </select>
  
  <select id="findByIds" parameterType="list" resultType="user">
    <include refid="selectUser"></include>
    <where>
      <foreach collection="list" open="id in(" close=")" item="id" separator=",">
        #{id}
      </foreach>
    </where>
  </select>
    
</mapper>

测试类：MapperTest

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class MapperTest {

    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //模拟ids的数据
        List<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(2);
        ids.add(4);
        List<User> userList = userMapper.findByIds(ids);
        System.out.println(userList);

    }

}

效果：

也是可以通过测试的。

mybatis映射文件深入-动态sql-知识小结

mybatis核心配置文件深入-typeHandler概述

typeHandler标签主要进行类型处理器的定义的。
在进行项目开发时一般把Java对象中的数据，转移到statement中，有个占位符的位置。
在查询时，会把查询出的resultset中的数据，转移到对象中，在转换的过程中就涉及数据类型的转换。
JDBC类型（可以认为是MySQL类型）和Java类型，是不一样的。
比如Java类型是String到数据库中就是varchar，这种转换关系不用我们去做。
因为mybatis本身就提供一系列的类型处理器。
按照它默认的类型处理器，进行相应的类型转换。
Java类型的某些数据，在进入到数据库时，可能需要自定义一些类型转换器。
（可能没有对应的类型转换器，或者这个类转换器不满足我预期的目的）
就得需要自定义 类型转换器。

mybatis核心配置文件深入-typeHandler测试环境搭建

pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lyh</groupId>
  <artifactId>spring_demo_01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring_demo_01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>
</project>

类：User

package com.lyh.domain;

import java.util.Date;

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday; //新添加的Date

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //方便测试，写上toString()方法

    @Override
    public String toString() {
        return "User{" +
            "id=" + id +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            ", birthday=" + birthday +
            '}';
    }
}

接口：UserMapper

package com.lyh.mapper;

import com.lyh.domain.User;

public interface UserMapper {
    public void save(User user);
}

UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lyh.mapper.UserMapper">
  <insert id="save" parameterType="user">
    insert into user values (#{id},#{username},#{password},#{birthday})
  </insert>

</mapper>

jdbc.properties文件：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=1234

jdbc.properties文件：

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:/mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
### 级别是信息级别的info 改为debug ###
log4j.rootLogger=debug, stdout

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>
  <!--    通过properties加载外部properties文件-->
  <properties resource="jdbc.properties"/>

  <!--    自定义别名 -->
  <typeAliases>
    <typeAlias type="com.lyh.domain.User" alias="user"/>
  </typeAliases>

  <!--    数据源环境-->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"></transactionManager>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>

  <!--    加载映射文件-->
  <mappers>
    <mapper resource="com/lyh/mapper/UserMapper.xml"/>
  </mappers>


</configuration>

测试类：MapperTest

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class MapperTest {

    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //创造user对象
        User user = new User();
        user.setUsername("ceshi");
        user.setPassword("abc");
        user.setBirthday(new Date());//new Date()，当前时间
        //执行保存操作
        userMapper.save(user);

        sqlSession.commit();
        sqlSession.close();

    }

}

效果：

因为Java中是Date类型，而数据库中是bigint类型，目前还没有办法进行转换。就会报错
这就需要进行自定义类型转换器。（把时间转换成毫秒值再插入到数据库中)

mybatis核心配置文件深入-自定义DateTypeHandler实现

BaseTypeHandle，T（泛型）就是要转换的Java类型Date
setNonNullParameter：将内部的Java类型的数据，转成数据库需要的数据类型。（就是将Java中的Date类型转换成数据库中的毫秒值）
getNullableResult：将数据库中的数据类型，转换成Java的数据类型。（就是将数据库中的毫秒值转换成Java中的Date类型)
回调方法，由mybatis自动去调用。

User类：

package com.lyh.domain;

import java.util.Date;

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday; //新添加的Date

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //方便测试，写上toString()方法

    @Override
    public String toString() {
        return "User{" +
            "id=" + id +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            ", birthday=" + birthday +
            '}';
    }
}

DateTypeHandler类：

package com.lyh.handler;

import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class DateTypeHandler extends BaseTypeHandler<Date> {

    //将Java类型转换成数据库需要的类型
    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, Date date, JdbcType jdbcType) throws SQLException {
        //将date转换成数字 getTime()就是获得的时间毫秒值
        long time = date.getTime();
        
        //通过 preparedStatement 设置参数
        //i就是当前参数的位置，当前参数就是date
        preparedStatement.setLong(i,time);
    }

    //将数据库中的类型转换成Java类型
    @Override
    //String参数：是数据库中 要转换的字段的名称
    //ResultSet：就是查询出的结果集（从结果集中取出数据，转换成Date再返回）
    public Date getNullableResult(ResultSet resultSet, String s) throws SQLException {
        //获得结果集中的数据（数据库中是bigint，这里是long类型的）转换成Date类型，并返回
        long aLong = resultSet.getLong(s);//里面的参数填写s就可以了，可以根据脚标（位置）获取，也可以根据字段名称获取
        Date date = new Date(aLong);
        return date;
    }

    //将数据库中的类型转换成Java类型
    @Override
    public Date getNullableResult(ResultSet resultSet, int i) throws SQLException {
        long aLong = resultSet.getLong(i);// i 是字段的位置
        Date date = new Date(aLong);
        return date;
    }

    //将数据库中的类型转换成Java类型
    @Override
    public Date getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        long aLong = callableStatement.getLong(i);
        Date date = new Date(aLong);
        return date;
    }
}

UserMapper类：

package com.lyh.mapper;

import com.lyh.domain.User;

public interface UserMapper {
    public void save(User user);
    public User findById(int id);
}

MyBatis核心配置文件中进行注册：

<typeHandlers>
	<typeHandler handler="package com.lyh.handler.DateTypeHandler"></typeHandler>
</typeHandlers>

UserMapper.xml配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lyh.mapper.UserMapper">
  <insert id="save" parameterType="user">
    insert into user values (#{id},#{username},#{password},#{birthday})
  </insert>

  <select id="findById" parameterType="int" resultType="user">
    select * from user where id=#{id}
  </select>

</mapper>

测试类：MapperTest

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class MapperTest {

    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //创造user对象
        User user = new User();
        user.setUsername("ceshi");
        user.setPassword("abc");
        user.setBirthday(new Date());//new Date()，当前时间
        //执行保存操作
        userMapper.save(user);

        sqlSession.commit();
        sqlSession.close();

    }

    //查询
    @Test
    public void test2() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.findById(7);
        System.out.println("==user中的birthday：=="+user.getBirthday());
        sqlSession.commit();
        sqlSession.close();

    }

}

test1效果：

test2效果：

mybatis核心配置文件深入-plugins标签介绍和查询全部代码编写

先做一个查询全部的功能。
UserMapper接口：

package com.lyh.mapper;

import com.lyh.domain.User;
import java.util.List;

public interface UserMapper {
    //查询全部的功能
    public List<User> findAll();
}

UserMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

    <mapper namespace="com.lyh.mapper.UserMapper">
        <!--优秀！-->
        <select id="findAll" resultType="user">
        	select * from user
        </select>
    </mapper>

MapperTest类：

package com.lyh.test;

//ibatis是mybatis的前身
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class MapperTest {
  
    //查询全部
    @Test
    public void test3() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();

    }

}

效果：

mybatis核心配置文件深入-plugins分页助手的代码实现

pom.xml文件：添加两个分页相关的依赖

<dependency>
  <groupId>com.github.pagehelper</groupId>
  <artifactId>pagehelper</artifactId>
  <version>3.7.5</version>
</dependency>

<dependency>
  <groupId>com.github.jsqlparser</groupId>
  <artifactId>jsqlparser</artifactId>
  <version>0.9.1</version>
</dependency>

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>
  <!--    通过properties加载外部properties文件-->
  <properties resource="jdbc.properties"/>

  <!--    自定义别名 -->
  <typeAliases>
    <typeAlias type="com.lyh.domain.User" alias="user"/>
  </typeAliases>

  <!--自定义 注册类型处理器-->
  <typeHandlers>
    <typeHandler handler="com.lyh.handler.DateTypeHandler"/>
  </typeHandlers>

  <!--    配置分页助手插件-->
  <plugins>
    <!--                  导入的pagehelper的，核心功能类-->
    <plugin interceptor="com.github.pagehelper.PageHelper">
      <!--            指定一下方言参数-->
      <!--            方言代表不同的数据库使用的sql结构化查询语言是不一样的-->
      <property name="dialect" value="mysql"/>
    </plugin>
  </plugins>

  <!--    数据源环境-->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"></transactionManager>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>

  <!--    加载映射文件-->
  <mappers>
    <mapper resource="com/lyh/mapper/UserMapper.xml"/>
  </mappers>


</configuration>

MapperTest类：进行测试

package com.lyh.test;

//ibatis是mybatis的前身
import com.github.pagehelper.PageHelper;
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class MapperTest {
    //查询全部
    @Test
    public void test3() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //设置分页的相关参数 当前页+每页显示的条数
        //          第2页，每页显示3条
        PageHelper.startPage(2,3);

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

    }

}

效果：

mybatis核心配置文件深入-plugins分页助手的分页相关数据获取

MapperTest类：

package com.lyh.test;

//ibatis是mybatis的前身
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.lyh.domain.User;
import com.lyh.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class MapperTest {

    //查询全部
    @Test
    public void test3() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //设置分页的相关参数 当前页+每页显示的条数
        //           第1页，每页显示3条
        PageHelper.startPage(1,3);

        List<User> userList = userMapper.findAll();
        for (User user : userList) {
            System.out.println(user);
        }

        //获得与分页相关的参数
        //PageHelper 这个插件里面 有PageInfo
        //PageInfo里面有个泛型，表示对谁进行分页，这里是对User进行分页
        //userList是查询出的所有的数据
        //根据当前设置的参数，当前页数是第1页，每页有3个数据，又根据当前查询的所有数据
        //可以逆向的推导出其他与分页相关的数据
        PageInfo<User> pageInfo = new PageInfo<User>(userList);
        System.out.println("当前页："+pageInfo.getPageNum());
        System.out.println("每页显示条数："+pageInfo.getPageSize());
        System.out.println("总条数："+pageInfo.getTotal());
        System.out.println("总页数："+pageInfo.getPages());
        System.out.println("上一页："+pageInfo.getPrePage());
        System.out.println("下一页："+pageInfo.getNextPage());
        System.out.println("是否是第一页："+pageInfo.isIsFirstPage());
        System.out.println("是否是最后一页："+pageInfo.isIsLastPage());
		sqlSession.close();
    }

}