Mybatis----入门程序

1.对原生态jdbc程序中问题总结

1.问题总结

1.数据库连接，使用时就创建，不使用立即释放，对数据库进行频繁连接开启和关闭，造成数据库资源浪费，影响数据库的性能。

设想：使用数据库连接池管理数据库连接。

2.将sql语句硬编码到Java代码中，如果sql语句修改，需要重新编译Java代码，不利于系统的维护。

设想：将sql语句配置在xml配置文件中，即使sql变化，不需要对Java代码进行重新编译。

3.向prepareedStatement中设置参数，对占位符号位置和设置参数值，硬编码在Java代码中，不利于系统维护。

设想：将sql语句及占位符和参数全部配置在xml中。

4.从resultSet中遍历结果集数据时，存在硬编码，将获取表的字段进行硬编码，不利于系统维护。

设想：将查询的结果集自动的映射成对象。

2.mybatis框架

2.1mybatis是什么？

mybatis是一个持久层的框架，是Apache下的顶级项目。

mybatis托管到goolecode下，再后来托管到github下（https://github.com/mybatis/mybatis-3/releases）。

mybatis让程序员将主要精力放在sql上，通过mybatis提供的映射方式，自由灵活生成（半自动化，大部分需要程序员编写sql）满足需要的sql语句。

mybatis可以将向prepareedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成Java对象（输出映射）。

2.2mybatis框架

3.入门程序

3.1需求

根据用户id（主键）查询用户信息

根据用户名称模糊查询用户信息

添加用户

删除用户

更新用户

3.2环境

mybatis运行环境（jar包）：

从https://github.com/mybatis/mybatis-3/releases下载，3.2.7版本。

 

*(*需要添加的jar包)lib下：依赖包-->log4j的操作所需包

*mybatis-3.2.7.jar：核心包

mybatis-3.2.7.pdf：操作指南

*加入MySQL的驱动包

可设置一个config包下面创建文件

 3.3 log4j

在应用的类路径下（src）创建一个名为log4j.properties的文件

# Global logging configuration
#在开发环境下日志级别设置成DEBUG，生产环境设置成info或error
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

3.4 创建SqlMapConfig.xml配置文件

在src下创建该文件

...后面根据需要进行相应的添加

配置mybatis的运行环境、数据源、事务等

在这个配置文件中加载映射文件

<?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>
    <!-- 和spring整合后 environments配置将废除-->
    <environments default="development">
        <environment id="development">
        <!-- 使用jdbc事务管理，事务的控制由mybatis进行-->
            <transactionManager type="JDBC" />
        <!-- 数据库连接池，由mybatis管理-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    
　　

　　<!-- 加载映射文件 -->
　　<mappers>
　　　　<mapper resource="sqlmap/User.xml"/>
　　</mappers>

</configuration>

3.5创建mapper.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约束 -->

<!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离
注意：使用mapper代理方法开发，namespace有特殊重要的作用
 -->
<mapper namespace="test">
    <!-- 在映射文件中配置很多sql语句 -->
    
    <!-- 通过select执行数据库查询 
        id:标识映射文件中的sql，称为statement的id
        将来sql语句封装到mappedstatement对象中，所以将id称为statement的id
        parameterType:指定输入参数的类型
        #{}表示一个占位符
        #{id}:其中的id表示接收输入的参数，参数的名称就是id，如果输入参数是简单类型，#{}中的参数名可以任意
        resultType:指定sql输出结果所映射的Java对象类型
    -->
    <select id="findUserById" parameterType="int" resultType="com.xjs.mybatis.po.User">
        SELECT * from USER WHERE id=#{id}
    </select>
    
</mapper>

 在创建config包的时候，将它设置为build path-->Use As Source Folder资源目录。

一开始是因为默认的情况下，只有src是build path的source folder目录，自定义的文件夹在Use as Source Folder前只是一个普通的文件夹，默认的情况下不会被加载，需要手动将自定义的文件夹加载为source folder。（它们图标是不一样的）

代码：

User.java：

package com.xjs.mybatis.po;

import java.util.Date;

/**
 * 
 * @author hp
 *
 */
public class User {
    
    // 属性名和数据库表的字段对应
    private int id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

    public User(int id, String username, String sex, Date birthday, String address) {
        super();
        this.id = id;
        this.username = username;
        this.sex = sex;
        this.birthday = birthday;
        this.address = address;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex + ", birthday=" + birthday + ", address="
                + address + "]";
    }

    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 getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

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

    public String getAddress() {
        return address;
    }

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



}

测试类：

package com.xjs.mybatis.first;

import java.io.IOException;
import java.io.InputStream;

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 com.xjs.mybatis.po.User;

/**
 * 入门程序
 * @author hp
 *
 */
public class MybatisFirst {
    
    //根据id查询用户信息
    @Test
    public void findUserById() throws IOException {
        //创建会话工厂
        String resource="SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
        //通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        
        //通过SqlSession操作数据库
        //第一个参数：映射文件中statement的id，等于namespace+"."+statement的id
        //第二个参数：指定和映射文件中所匹配的parameterType类型的参数
        //sqlSession.selectOne结果是与映射文件中所匹配resultType类型的对象
        User user = sqlSession.selectOne("test.findUserById", 1);
        
        System.out.println(user);
        
        //释放资源
        sqlSession.close();
        
    }
}

 根据用户名模糊查询：

映射文件

    <!-- 根据用户名称模糊查询用户信息 ,可能多条
        resultType:指定就是单条记录所映射的Java对象类型
        ${}:表示拼接sql串，将接收到的参数的内容不加任何修饰拼接在sql中。
        使用${}拼接sql，引起sql注入
        ${value}:接收输入参数的内容，如果传入类型是简单类型，${}中只能使用value 
    -->
    <select id="findUserByName" parameterType="java.lang.String" resultType="com.xjs.mybatis.po.User">
        SELECT * FROM USER WHERE username LIKE '%${value}%'
    </select>

测试

    // 根据用户名模糊查询用户列表
    @Test
    public void findUserByNameTest() throws IOException {
        // 创建会话工厂
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //查询
        List<User> list = sqlSession.selectList("test.findUserByName", "小明");
        System.out.println(list);
        
        sqlSession.close();
    }

3.6 添加用户

3.6.1映射文件

    <!-- 添加用户 
        parameterType:指定输入参数类型是pojo(包括用户信息)
        #{}中指定pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值
    -->
    <insert id="insertUser" parameterType="com.xjs.mybatis.po.User">
        insert into user(id,username.birthday,sex,address) value(#{id},#{username},#{birthday},#{sex},#{address})
    </insert>

3.6.2程序代码

    // 添加用户信息
        @Test
        public void insertUserTest() throws IOException {
            // 创建会话工厂
            String resource = "SqlMapConfig.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            // 通过工厂得到SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //插入
            User user=new User();
            user.setUsername("金泰妍");
            user.setBirthday(new Date());
            user.setSex("1");
            user.setAddress("河南安阳");
            
            int i = sqlSession.insert("test.insertUser", user);

            //执行提交事务
            sqlSession.commit();
            System.out.println("受影响的行数"+i);
            //关闭会话
            sqlSession.close();
        }

3.6.3自增主键返回

　　mysql自增主键，执行insert提交之前自动生成一个自增主键。

通过mysql函数获取到刚插入记录的自增主键：

LAST_INSERT_ID()

是在insert之后调用

    <!-- 添加用户 
        parameterType:指定输入参数类型是pojo(包括用户信息)
        #{}中指定pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值
    -->
    <insert id="insertUser" parameterType="com.xjs.mybatis.po.User">
        <!-- 将插入数据的主键返回，返回到user对象中
            SELECT LAST_INSERT_ID():得到刚insert进去记录的主键值，只适用于自增主键
            keyProperty:将查询到主键值设置到parameterType指定的对象的哪个属性（id属性）
            order:SELECT LAST_INSERT_ID()执行顺序，相对于insert语句来说它的执行顺序
            resultType:指定SELECT LAST_INSERT_ID()的结果类型
         -->
        <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
            SELECT LAST_INSERT_ID()
        </selectKey>
        insert into user(username,birthday,sex,address) value(#{username},#{birthday},#{sex},#{address})
    </insert>

可在测试的时候：user.getId();

3.6.4非自增主键返回（使用uuid()）

　　使用mysql的uuid( )函数生成主键，需要修改表中id字段类型为String，长度设置成35位。

执行思路：

先通过uuid()查询到主键，将主键查询到sql语句中。

执行uuid()语句顺序相对于insert语句之前执行。

        <!-- 
        使用mysql的uuid()生成主键
        执行过程：
        首先通过uuid()得到主键，将主键设置到user对象的id属性中
        其次在insert执行时，从user对象中取出id属性值
         -->
        <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">
            SELECT uuid()
        </selectKey>
        insert into user(id,username,birthday,sex,address) value(#{id},#{username},#{birthday},#{sex},#{address})

3.7删除用户

3.7.1映射文件

    <!-- 删除用户 
    根据id删除用户，需要输入id值
    -->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{id}
    </delete>

3.7.2代码实现

    //根据用户id删除用户信息
    @Test
    public void deleteUserTest() throws IOException {
        // 创建会话工厂
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //删除

        int i = sqlSession.delete("test.deleteUser", 28);
        // 执行提交事务
        sqlSession.commit();
        System.out.println("删除受影响的行数" + i);
        // 关闭会话
        sqlSession.close();
    }

3.8更新用户

3.8.1映射文件

    <!-- 根据id更新用户 
    需要传入用户id
    需要传入用户的更新信息
    paramterType指定user对象，包括id和更新信息，注意：id必须存在
    #{id}:从输入user对象中获取id属性值
    -->
    <update id="updateUser" parameterType="com.xjs.mybatis.po.User">
        update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}
        where id=#{id}
    </update>

3.8.2代码实现

    // 根据用户id更新用户信息
    @Test
    public void updateUserTest() throws IOException {
        // 创建会话工厂
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 插入
        User user = new User();
        user.setId(35);
        user.setUsername("IU");
        user.setBirthday(new Date());
        user.setSex("2");
        user.setAddress("韩国");

        int i = sqlSession.update("test.updateUser", user);
        // 执行提交事务
        sqlSession.commit();
        System.out.println("更新受影响的行数" + i);
        // 关闭会话
        sqlSession.close();
    }

3.9总结

3.9.1parameterType

在映射文件中通过parameterType指定输入参数类型。

3.9.2resultType

在映射文件中通过resultType指定输出结果的类型。

3.9.3 #{ }和 ${ }

#{ }表示一个占位符号，#{ }接收输入参数，类型可以是简单类型，POJO、hashmap。

如果是接收简单类型，#{ }中可以写成value或其它名称。

#{ }接收POJO对象值，通过OGNL读取对象中的属性值，通过属性.属性.属性...的方式获取对象属性值。 

${ }表示一个拼接符号，会引起sql注入，所以不建议使用${ }。

${ }接收输入参数，类型可以是简单类型，POJO、hashmap。

如果是接收简单类型，${ }中只能写成value。

${ }接收POJO对象值，通过OGNL读取对象中的属性值，通过属性.属性.属性...的方式获取对象属性值。

3.9.4selectOne和selectList

selectOne表示查询出一条记录进行映射。

selectList表示查询出一个列表（多条记录）进行映射。

3.10mybatis和hibernate本质区别和应用场景

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

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

应用场景：

　　适用于需求变化不多的中小型项目，比如：后台管理系统，erp、orm、oa。

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

应用场景：

　　适用于需求变化较多的项目，比如：互联网项目。