Mybatis 基本使用

工程结构：

1、在test库创建表student（MySql数据库）

2、创建实体类Student.java

package com.gdut.testMybatis.vo;

public class Student {
    private int id;
    private String name;
    
    public Student() {
        super();
    }
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }

}

3、写Dao接口

package com.gdut.testMybatis.dao;

import java.util.List;
import java.util.Map;

import com.gdut.testMybatis.vo.Student;

public interface IStudentDao {
    void insertStudent(Student student); //添加
     
    void insertStudentCacheId(Student student);//添加并返回此学生id
 
    void deleteStudentById(int id);//删除学生
 
    void updateStudentById(Student student);//修改学生
 
    List<Student> selectAllStudents();//查询所有学生，返回List
 
    Map<String, Object> selectAllStudentsMap();//查询所有学生，返回Map
 
    Student selectById(int id);//根据id查询
 
    List<Student> selectByName(String name);//根据name查询

}

4、配置studentMapper.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.gdut.testMybatis.dao.IStudentDao">
     <insert id="insertStudent" parameterType="Student"><!-- mapper动态代理。其底层自动实现Dao接口 -->
         insert into student(id,name) values(#{id}, #{name})
         <!-- name是表字段，#{name}这个name是属性，mybatis会自动添加get方法获取属性值，不是成员变量 -->
     </insert>
 
 
     <insert id="insertStudentCacheId" parameterType="Student">
         insert into student(id,name) values(#{id},#{name})
         <!-- mysql:AFTER  oracle：BEFORE  mysql是先插入后有id -->
         <selectKey resultType="int" keyProperty="id" order="AFTER"> 
             select @@identity
         </selectKey>
     </insert>
 
 
    <delete id="deleteStudentById">
        delete from student where id = #{xxx}   <!-- 这块的#{}仅仅是一个占位符，可以随便指定值 -->
    </delete>     
    
    <update id="updateStudentById" parameterType="Student">
        update student set name=#{name} where id=#{id}
    </update>
    
    <select id="selectAllStudents" resultType="Student">
        select id,name from student 
    </select>
    
    <select id="selectById" resultType="Student">
        select id,name from student where id=#{id}
    </select>
    
    <select id="selectByName" resultType="Student">
        <!-- 推荐使用这种 -->
         select id,name from student where name like '%' #{xxx} '%'    
         <!-- select id,name,age,score from student where name like concat('%',#{xxx},'%') -->
         <!-- 这种不建议使用，这种使用statement查询方式，有sql注入风险 -->
         <!-- select id,name,age,score from student where name like '%${value}%' --> 
    </select>
     
 </mapper>

5、mybatis.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>
    <!-- 别名 -->
    <typeAliases>
        <!-- <typeAlias type="com.gdut.testMybatis.vo.Student" alias="Student"/> -->
        <package name="com.gdut.testMybatis.vo"/>
    </typeAliases>
 
    <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://localhost:3306/test" />
                <property name="username" value="数据库用户名" />
                <property name="password" value="数据库密码" />
            </dataSource>
        </environment>
    </environments>
    
    <!-- 配置映射文件 -->
    <mappers>
        <mapper resource="com/gdut/testMybatis/dao/studentMapper.xml"/>
    </mappers>
</configuration>

6、编写utils类，用于创建SqlSession

package com.gdut.testMybatis.util;

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;

public class MyBatisUtils {
     
    private static SqlSessionFactory sqlSessionFactory;
 
    public static SqlSession getSqlSession() {
        try {
            InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
            if (sqlSessionFactory == null) {
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //build()方法会把inputStream关闭掉
            } else {
                inputStream.close();
            }
            return sqlSessionFactory.openSession();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

7、测试类Test1.java

package com.gdut.testMybatis;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.gdut.testMybatis.dao.IStudentDao;
import com.gdut.testMybatis.util.MyBatisUtils;
import com.gdut.testMybatis.vo.Student;

public class Test1 {
    IStudentDao dao;
     
    SqlSession  sqlSession;
 
    @Before
    public void before() {
        sqlSession = MyBatisUtils.getSqlSession();
        dao = sqlSession.getMapper(IStudentDao.class);
    }
 
    @After
    public void after() {
        if (sqlSession != null) {
            sqlSession.close();
        }
    }
 
    @Test
    public void test01() {
        Student student = new Student(4, "学生4");
        dao.insertStudent(student);
        sqlSession.commit();
    }
 
    @Test
    public void test02() {
        Student student = new Student(5, "学生5");
        System.out.println("插入前：" + student);
        dao.insertStudentCacheId(student);
        sqlSession.commit();
        System.out.println("插入后：" + student);
    }
 
    @Test
    public void test03() {
        dao.deleteStudentById(13);
        sqlSession.commit();
    }
 
    @Test
    public void test04() {
        Student student = new Student(4, "学生4-1" );
        student.setId(19);
        dao.updateStudentById(student);
        sqlSession.commit();
    }
 
    @Test
    public void test05() {
        List<Student> students = dao.selectAllStudents();
        for (Student student : students) {
            System.out.println(student);
        }
    }
 
    /* @Test
     public void test06() {
         Map<String, Object> map = dao.selectAllStudentsMap();
         System.out.println(map.get("张三"));
     }*/
 
    @Test
    public void test07() {
        Student student = dao.selectById(7);
        System.out.println(student);
    }
 
    @Test
    public void test08() {
        List<Student> students = dao.selectByName("学生3");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

配置文件默认都在类路径下面，即src文件夹下。

mapper.xml则是与Dao放在相同位置

Mpper.xml映射文件中定义了操作数据库的sql，并且提供了各种标签方法实现动态拼接sql。每个sql是一个statement，映射文件是mybatis的核心。

一、内容标签

1、NamePlace

NamePlace命名空间作用就是对sql进行分类化管理。若使用Dao开发方式，映射文件的nameplace可以任意命名；但如果采用的是Mapper接口代理的方式开发，Mapper的映射文件中namespace必须为接口的全名。

<?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="Mapper.EmpMapper">
    //CURD操作标签
        //if片段
</mapper>

2、CRUD标签

<?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="Mapper.EmpMapper">
    <!-- 查询 -->
    <select id="" parameterType="" resultType=""></select>

    <!-- 添加 -->
    <insert id="" parameterType=""></insert>

    <!-- 删除 -->
    <delete id="" parameterType=""></delete>

    <!-- 更新 -->
    <update id="" parameterType=""></update>
</mapper>

3、标签调用方法

（1）selectOne与selectList方法

selectOne表示查询出一条结果集进行映射，使用selectOne查询多条记录会抛出异常。selectList表示查询出一个列表（多条记录）进行映射，对于使用selectOne可以实现的查询，使用selectList必然也可以实现（list中只有一个对象）。

（3）代理对象内部调用

动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定，如果mapper方法返回单个pojo对象（非集合对象），代理对象内部通过selectOne查询数据库。如果mapper方法返回集合对象，代理对象内部通过selectList查询数据库。

二、动态SQL标签

1、if标签

//进行空字符串校验
<select id="findUserList" parameterType="user" resultType="user">
    select * from user  where 1=1
        <if test="id!=null and id!=''">
            and id=#{id}
        </if>
        <if test="username!=null and username!=''">
            and username like '%${username}%'
        </if>
</select>

2、where标签

//<where/>可以自动处理第一个and
<select id="findUserList" parameterType="user" resultType="user">
    select * from user
        <where>
            <if test="id!=null and id!=''">
                and id=#{id}
            </if>
            <if test="username!=null and username!=''">
                and username like '%${username}%'
            </if>
        </where>
</select>

3、sql片段

Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的，如下：

//建立sql片段
<sql id="query_user_where">
    <if test="id!=null and id!=''">
        and id=#{id}
    </if>
    <if test="username!=null and username!=''">
        and username like '%${username}%'
    </if>
</sql>

//使用include引用sql片段
<select id="findUserList" parameterType="user" resultType="user">
    select * from user
        <where>
            <include refid="query_user_where"/>
        </where>
</select>

//引用其它mapper.xml的sql片段
<include refid="namespace.sql片段"/>

三、foreach标签

1、通过pojo类传递list

向sql传递数组或List，mybatis使用foreach解析，foreach参数定义如下：collection指定输入对象中集合属性， item每个遍历生成对象中，open开始遍历时拼接的串，close结束遍历时拼接的串，separator：遍历的两个对象中需要拼接的串。

（1）sql语句

SELECT * FROM USERS WHERE username LIKE '%张%' AND (id =10 OR id =89 OR id=16)
SELECT * FROM USERS WHERE username LIKE '%张%' id IN (10,89,16)

（2）vo类

public class QueryVo{
	private User user;
        private UserCustom userCustom;
	//传递多个用户id
	private List<Integer> ids;
	set()/get()  ...
}

（3）映射文件

<select id="findUserList" parameterType="UserQueryVo" resultType="UserCustom">
     SELECT * FROM USER
     <where>
        <!-- 使用实现下边的sql拼接： AND (id=1 OR id=10 OR id=16) -->

        <if test="ids!=null and ids.size>0">

           <foreach collection="ids" item="user_id" open="AND (" close=")" separator="or">

                  id=#{user_id}

           </foreach>

       </if>
     </where> 
</select>

 

<!-- 使用实现下边的sql拼接： and id IN(1,10,16)—>

<foreach collection="ids" item="user_id" open="and id IN(" close=")" separator=",">

     #{user_id}

</foreach>

（4）测试代码

List<Integer> ids = new ArrayList<Integer>();
ids.add(1);//查询id为1的用户
ids.add(10); //查询id为10的用户
queryVo.setIds(ids);
List<User> list = userMapper.findUserList(queryVo);

2、传递单个list

（1）Mapper映射文件

<select id="selectUserByList" parameterType="java.util.List" resultType="user">
    select * from user
      <where>
      <!-- 传递List，List中是pojo -->
      <if test="list!=null">
         <foreach collection="list" item="item" open="and id in( "separator="," close=")">
            #{item.id}
         </foreach>
       </if>
     </where>
</select>

（2）Mapper接口

public List<User> selectUserByList(List userlist);

（3）测试程序

//构造查询条件List
List<User> userlist = new ArrayList<User>();
User user = new User();
user.setId(1);
userlist.add(user);

user = new User();
user.setId(2);
userlist.add(user);
//传递userlist列表查询用户列表
List<User>list = userMapper.selectUserByList(userlist);

3、传递pojo类数组

（1）Mapper映射文件

参数含义：index为数组的下标，item为数组每个元素的名称，名称随意定义，open循环开始,close循环结束，separator中间分隔输出。

<select id="selectUserByArray" parameterType="Object[]" resultType="user">
    select * from user
      <where>
         <!-- 传递pojo类数组 -->
        <if test="array!=null">
            <foreach collection="array" index="index" item="item"
                         open="and id in("separator=","close=")">
                    #{item.id}
            </foreach>
        </if>
       </where>
</select>

（2）Mapper接口

public List<User> selectUserByArray(Object[] userlist)

（3）测试程序

//构造查询条件List
Object[] userlist = new Object[2];
User user = new User();
user.setId(1);
userlist[0]=user;

user = new User();
user.setId(2);
userlist[1]=user;

//传递user对象查询用户列表
List<User>list = userMapper.selectUserByArray(userlist);

4、传递字符串类数组

（1）Mapper映射文件

<select id="selectUserByArray" parameterType="Object[]" resultType="user">
    select * from user
    <where>
        <!-- 传递字符串数组 -->
        <if test="array!=null">
            <foreach collection="array"index="index"item="item"
                    open="and id in("separator=","close=")">
                    #{item}
            </foreach>
        </if>
    </where>
</select>

如果数组中是简单类型则写为#{item}，不用再通过ognl获取对象属性值了。

（2）Mapper接口

public List<User> selectUserByArray(Object[] userlist)

（3）测试程序

//构造查询条件List
Object[] userlist = new Object[2];
userlist[0]=”1”;
userlist[1]=”2”;
//传递user对象查询用户列表
List<User>list = userMapper.selectUserByArray(userlist);

注意的问题：mybatis中#{}和${}的区别？

　在mybatis的mapper文件中，对于传递的参数我们一般是使用#和$来获取参数值。

　1. #{}是预编译处理，${}是字符串替换。
　　　Mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值；
　　　Mybatis在处理${}时，就是把${}替换成变量的值。

　2.使用#{}可以有效的防止SQL注入，提高系统安全性。
　　MyBatis排序时使用order by 动态参数时需要注意，用$而不是#

　　1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。
　　2. $将传入的数据直接显示生成在sql中。
　　3. #方式能够很大程度防止sql注入。
　　4.$方式无法防止Sql注入。
　　5.$方式一般用于传入数据库对象，例如传入表名。
　　6. #{}方式一般用于传入字段值。
　　7.一般能用#的就别用$。

动态 sql 是 mybatis 的主要特性之一，在 mapper 中定义的参数传到 xml 中之后，在查询之前 mybatis 会对其进行动态解析。mybatis 为我们提供了两种支持动态 sql 的语法：#{} 以及 ${} 。

1、#相当于对数据加上双引号，$相当于直接显示数据。

2、#{} ：根据参数的类型进行处理，比如传入String类型，则会为参数加上双引号。#{} 传参在进行SQL预编译时，会把参数部分用一个占位符 ? 代替，这样可以防止 SQL注入。
3、${} ：将参数取出不做任何处理，直接放入语句中，就是简单的字符串替换，并且该参数会参加SQL的预编译，需要手动过滤参数防止 SQL注入。
4、因此 mybatis 中优先使用 #{}；当需要动态传入表名或列名时，再考虑使用 ${} ，比较特殊，他的应用场景是需要动态传入表名或列名时使用，MyBatis排序时使用orderby动态参数时需要注意，用 {} 比较特殊，他的应用场景是需要动态传入表名或列名时使用，MyBatis排序时使用order by 动态参数时需要注意，用比较特殊，他的应用场景是需要动态传入表名或列名时使用，MyBatis排序时使用orderby动态参数时需要注意，用而不是#。

例如：
1、#对传入的参数视为字符串，也就是它会预编译，select * from user where user_name=${rookie}，比如我传一个rookie，那么传过来就是 select * from user where user_name = ‘rookie’；

2、$不会将传入的值进行预编译， select * from user where user_name= ${rookie} ,那么传过来的sql就是：select * from user where user_name=rookie;

3、#优势在于它能很大程度防止sql注入，$ 不行。比如：用户进行一个登录操作，后台sql验证式样的：
select * from user where user_name=#{name} and password = #{pwd}，如果前台传来的用户名是“rookie”，密码是 “1 or 2”，用#的方式就不会出现sql注入，换成用$ 方式，sql语句就变成了 select * from user where user_name=rookie and password = 1 or 2。这样的话就形成了sql注入。

分析一个问题：上面提到 MyBatis排序时使用order by 动态参数时需要注意，用$而不是#，为什么？

ORDER BY ${columnName}
这里MyBatis不会修改或转义字符串。

重要：接受从用户输出的内容并提供给语句中不变的字符串，这样做是不安全的。这会导致潜在的SQL注入攻击，因此你不应该允许用户输入这些字段，或者通常自行转义并检查。

#{}相当于jdbc中的preparedstatement

${}是输出变量的值

简单的说就是#{}传过来的参数带单引号''，而${}传过来的参数不带单引号。

你可能说不明所以,不要紧我们看2段代码:

String sql = "select * from admin_domain_location order by ?";
PreparedStatement st = con.prepareStatement(sql);
st.setString(1, "domain_id");
System.out.println(st.toString());

ResultSet rs = st.executeQuery();

while(rs.next()){
    System.out.println(rs.getString("domain_id"));
}

输出结果:

　　com.mysql.jdbc.PreparedStatement@1fa1ba1: select * from admin_domain_location order by 'domain_id'

这是个jdbc的preparedstatement例子,不要吐槽我这么写是否合法,这里只是为了说明问题.

以上例子有得出以下信息: 1) order by后面如果采用预编译的形式动态输入参数,那么实际插入的参数是一个字符串,例子中是:order by 'domain_id'

2)输出结果并没有排序,从sql语句中的形式我们也可以推测出此sql语句根本也不合法(正常应该是 order by domain_id )

修改以上代码如下:

String input = "domain_id";
String sql = "select * from admin_domain_location order by "+input;
PreparedStatement st = con.prepareStatement(sql);
System.out.println(st.toString());
ResultSet rs = st.executeQuery();
while(rs.next()){
    System.out.println(rs.getString("domain_id"));
}

输出结果:

　　com.mysql.jdbc.PreparedStatement@1fa1ba1: select * from admin_domain_location order by domain_id

此次我们直接把一个变量的值拼接sql语句,从结果可以看出来:

1)sql语句拼接正常

2)查询结果排序正常

你可能要问这和#{}与${}有什么关系..

上面已经说过#{}相当于jdbc的preparedstatement,所以以上的第一个例子就相当于#{},那么第二个例子就自然而然指的是${}的情况.

你可能说思维还是有些凌乱,不要紧我们来看第三个例子:

String sql = "select * from admin_domain_location where domain_id=?";
PreparedStatement st = con.prepareStatement(sql);
st.setString(1, "2");
System.out.println(st.toString());
ResultSet rs = st.executeQuery();
while(rs.next()){
  System.out.println(rs.getString("domain_id"));
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
String input = "2";
String sql = "select * from admin_domain_location where domain_id='"+input+"'";
PreparedStatement st = con.prepareStatement(sql);
System.out.println(st.toString());
ResultSet rs = st.executeQuery();
while(rs.next()){
  System.out.println(rs.getString("domain_id"));
}

输出结果都为：
　　com.mysql.jdbc.PreparedStatement@12bf560: select * from admin_domain_location where domain_id='2'

这第三个例子虽然说的是#{}和{}是通用的,只不过需要些小的转换.如例子中需要手动

拼接单引号 ' ' 到变量值的前后,确保sql语句正常.

简单说#{}是经过预编译的,是安全的,而${}是未经过预编译的,仅仅是取变量的值,是非安全的,存在sql注入.

这里先说一下只能{}了,用#{}会多个' '导致sql语句失效.此外还有一个like 语句后也需要用${},简单想一下

就能明白.由于{},那么不做任何处理的时候是存在sql注入危险的.你说怎么防止,那我只

能悲惨的告诉你,你得手动处理过滤一下输入的内容,如判断一下输入的参数的长度是否正常(注入语句一般很长),更精确写查询一下输入的参数是否在预期的参数集合中..