Mybatis笔记一

1. mybatis框架的介绍

1、jdbc中的代码

package com.itheima;

import com.itheima.domain.User;
import org.junit.Test;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 回顾jdbc代码
 */
public class TestJDBC {

    @Test
    public void test(){

        List<User> userList = new ArrayList<>();

        //1. 注册驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        String url = "jdbc:mysql://localhost:3306/mybatisdb_331";
        String username = "root";
        String password = "root";
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rs = null;
        try {
            //2. 获取连接
            conn = DriverManager.getConnection(url, username ,password);
            // 3. SQL语句
            String sql = "select * from user";
            //4. 创建statement对象: Statement , PreparedStatement
            pst = conn.prepareStatement(sql);
            //5. 执行SQL语句，返回结果集
            rs = pst.executeQuery();
            //6. 处理结果集
            while(rs.next()){//判断是否有下一条记录，如果有，说明有一个User对象
                User user = new User();
                //获取ResultSet中的值，赋值给user对象
                int id = rs.getInt("id");
                user.setId(id);
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setSex(rs.getString("sex"));
                user.setAddress(rs.getString("address"));
                //添加到集合中
                userList.add(user);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //7. 释放资源: 先开后关
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(pst != null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

        //打印结果
        for (User user : userList) {
            System.out.println(user);
        }

    }
}

2、jdbc代码中的问题

a、频繁创建和释放数据库的连接对象，造成资源的浪费. 使用数据库连接池可以解决（c3p0 ,dbcp, spring jdbc ,durid）
b、sql语句硬编码(写死),如果数据库发生改变，需要重新编译代码，再运行 。 可以考虑把sql语句写到配置文件中
c、传参数硬编码，必须按照特定的顺序传参
d、处理结果集硬编码，如果改变了数据库，结果集的映射必须重新写，需要重新编译代码，再运行
e、连接的配置信息硬编码

2. 自定义框架（原理）

3. Mybatis框架的快速入门（重点）

1、添加依赖(jar)

 <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2、编写pojo对象

package com.itheima.domain;

/**
 * 包装类型： 初始值为null
 * 基本数据类型：本身的值就是一个状态
 *
 */
public class User {
    private Integer id;
    private String username;
    private String password;
    private String sex;
    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

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

    public String getSex() {
        return sex;
    }

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

    public String getAddress() {
        return address;
    }

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

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

3、编写映射文件

<?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.itheima.dao.UserDao">
    <select id="findAll" resultType="com.itheima.domain.User">
        select * from user
    </select>
</mapper>

4、编写核心配置文件

<?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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatisdb_331?characterEncoding=utf8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    <!--关联映射文件-->
	<mappers>
		<mapper resource="com/itheima/mapper/UserMapper.xml"></mapper>
    </mappers>
</configuration>

5、测试框架

package com.itheima;


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.InputStream;
import java.util.List;

public class TestCustomFrame {

    @Test
    public void test(){
        //获取配置文件的输入流对象
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //创建SqlSessionFactory对象
        SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        //获取sqlSession对象
        SqlSession sqlSession = sessionFactory.openSession();
        //执行sql语句
        List list = sqlSession.selectList("com.itheima.dao.UserDao.findAll");
        //遍历结果集
        for (Object o : list) {
            System.out.println(o);
        }
        //关闭资源
        sqlSession.close();
    }
}

4. mybatis实现CRUD

a、mybatis 的中文文档网址：http://www.mybatis.org/mybatis-3/zh/getting-started.html
b、 selectList 查询多个对象,返回一个list集合(也能查询一个)
    selectOne: 查询单个对象，返回一个对象
c、日志记录日常操作
	引入依赖: 
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
  引入日志的配置文件：log4j.properties
 d、增删改查
 	<!--UserMapper删除操作-->
    <delete id="del" parameterType="java.lang.Integer">
        delete from user where id = #{id}
    </delete>
 	<!--测试类-->   
    @Test
    public void testDel(){
        //获取输入流对象
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("SqlMapConfig.xml");
        //获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        //获取的sqlsession不能自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //执行sql语句
        sqlSession.delete("userMapper.del",3);
        //提交:只要修改了数据库必须提交
        sqlSession.commit();

        sqlSession.close();
    }
 e、模糊查询
 	参数： %a% 
 		配置文件： username like #{username}
 	参数: a
 		配置文件1： username like "%"#{username}"%"
 		配置文件2： username like "%${value}%"
 							如果传的是简单类型必须使用value
 							如果是pojo,属性名引用
 d、参数
 		简单类型： 基本数据类型,String
 				如果${} 必须用value引用
 				如果#{} 随便写
 		pojo类型：属性名引用	
 e、${} 与 #{}区别
 	${}:直接拼接,不会转换类型, 不能防注入
 	#{}:转换类型后拼接, 相当于占位符?,可以防注入

5. 两种Dao开发

1、传统dao开发
2、动态代理模式开发

6. 核心配置文件详解

1. 配置文件中的标签和顺序
properties?, 						配置属性(学习)
settings?, 							全局配置：缓存，延迟加载
typeAliases?, 					类型别名(学习)
typeHandlers?, 					类型转换(操作)(了解)
objectFactory?, 	 objectWrapperFactory?,  reflectorFactory?, 
plugins?, 							插件:分页插件
environments?, 					环境配置（数据源）
databaseIdProvider?, 		
mappers?								引入映射配置文件(学习)

? : 一个或者零个
| : 任选其一
+ : 最少一个
* : 零个或多个
, : 必须按照此顺序编写

6. 输入参数类型和输出参数类型

1. 输入参数
	简单类型: 基本数据类型+ String类型
				#{} :名称随便
				${} :${value}
	pojo 类型
		#{} :${} : 属性名引用
	包装对象类型
		引用  #{属性.属性名}
	Map集合
		引用： #{key}
	多个参数
		引用时：#{param1},#{param2}.....#{paramN}
2. 返回值类型
	如果列与属性名不一致，对应的属性为null, 必须写映射配置