Mybatis学习笔记之---动态sql中标签的使用

动态Sql语句中标签的使用

（一）常用标签

1.<if>

if标签通常用于WHERE语句中，通过判断参数值来决定是否使用某个查询条件， 他也经常用于UPDATE语句中判断是否更新某一个字段，还可以在INSERT语句中用来判断是否插入某个字段的值

2.<where>

where元素的作用是给SQL语句添加一个条件判断. 如果输出后是and 开头的，MyBatis会把第一个and忽略，当然如果是or开头的，MyBatis也会把它忽略；此外，在where元素中你不需要考虑空格的问题，MyBatis会智能的帮你加上

3.<foreach>

主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。

foreach元素的属性主要有item，index，collection，open，separator，close

collection属性的值有三个分别是list、array、map三种，分别对应的参数类型为：List、数组、map集合

　　　　item ： 表示在迭代过程中每一个元素的别名

　　　　index ：表示在迭代过程中每次迭代到的位置（下标）

　　　　open ：前缀

　　　　close ：后缀

　　　　separator ：分隔符，表示迭代时每个元素之间以什么分隔

（二）应用

1.pom.xml

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.41</version>
  </dependency>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
  </dependency>
</dependencies>

2.SqlMapperConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
 
<!DOCTYPEconfiguration
 
        PUBLIC"-//mybatis.org//DTD Config 3.0//EN"
 
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
 
<!--mybatis的主配置文件-->
 
<configuration>
 
    <!--配置环境-->
 
    <environments default="mysql">
 
        <!--配置mysql环境-->
 
        <environment id="mysql">
 
            <!--配置事务的类型-->
 
            <transactionManager type="JDBC"></transactionManager>
 
            <!--配置数据源（连接池）-->
 
            <dataSource type="POOLED">
 
                <!--配置连接数据库的4个基本信息-->
 
                <property name="driver" value="com.mysql.jdbc.Driver"></property>
 
                <property name="url" value="jdbc:mysql://localhost:3306/zml?useUnicode=true&amp;characterEncoding=utf-8"></property>
 
                <property name="username" value="root"></property>
 
                <property name="password" value="root"></property>
 
            </dataSource>
 
        </environment>
 
    </environments>
 
    <!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件-->
 
<mappers>
 
    <mapper resource="dao/UserDao.xml"></mapper>
 
</mappers>
 
</configuration>

3.Users.java

package entity;
 
public class Users {
 
    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;
 
    }
 
    @Override
 
    public String toString() {
 
        return "Users{" +
 
                "id=" + id +
 
                ", username='" + username + '\'' +
 
                ", password='" + password + '\'' +
 
                '}';
 
    }
 
}

4.UserVo.java

package entity;
 
import java.util.List;
 
public class UserVo {
 
    private Users users;
 
    private List<Integer> ids;
 
    public Users getUsers() {
 
        return users;
 
    }
 
    public void setUsers(Users users) {
 
        this.users = users;
 
    }
 
    public List<Integer> getIds() {
 
        return ids;
 
    }
 
    public void setIds(List<Integer> ids) {
 
        this.ids = ids;
 
    }
 
}

5.UserDao.java

package dao;
 
        import entity.UserVo;
 
        import entity.Users;
 
        import org.apache.ibatis.annotations.Param;
 
        import java.util.List;
 
public interface UserDao {
 
     //查询所有用户信息
 
     List<Users> findAll();
 
     //根据ID进行查询
 
     Users find(int id);
 
     //模糊查询
 
     List<Users> findVague(String name);
 
     //查询用户总数
 
     int count();
 
     //将实体类封装到另一个实体类中的模糊查询
 
     List<Users> findVo(UserVo vo);
 
     //根据传入参数进行查询
 
     Users findby(Users users);
 
     //根据UserVo中的ids集合查询用户信息
 
     List<Users> findids(UserVo vo);
 
}

6.UserDao.xml

<?xml version="1.0" encoding="UTF-8" ?>
 
<!DOCTYPEmapper
 
        PUBLIC"-//mybatis.org//DTD Mapper 3.0//EN"
 
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 
<mapper namespace="dao.UserDao">
 
    <!--查询所有-->
 
    <select id="findAll" resultType="entity.Users">
 
        select * from users
 
    </select>
 
    <!--根据ID查询-->
 
    <select id="find" resultType="entity.Users">
 
        select * from users where id=#{id}
 
    </select>
 
    <!--模糊查询-->
 
    <select id="findVague" resultType="entity.Users">
 
--         select * from users where username like '%${value}%'
 
        select * from users where username like #{name}
 
    </select>
 
    <!--查询用户总数-->
 
    <select id="count" resultType="int">
 
        select count(id) from users
 
    </select>
 
    <!--将实体类封装到另一个实体类中的模糊查询-->
 
    <select id="findVo" resultType="entity.Users">
 
        select * from users where username like #{users.username}
 
    </select>
<!--根据传入参数进行查询-->
 
    <select id="findby" resultType="entity.Users" >
 
        select * from users
 
        <where>
 
        <if test="id != null">
 
        and id=#{id}
 
        </if>
 
        <if test="username != null">
 
            and username=#{username}
 
        </if>
 
        </where>
 
    </select>
 
    <!--根据UserVo中的ids集合实现查询用户列表-->
 
    <select id="findids" resultType="entity.Users" parameterType="entity.UserVo">
 
        select * from users
 
        <where>
 
            <if test="ids != null and ids.size()>0">
 
                <foreach collection="ids" open="and id in (" close=")" item="id" separator=",">
 
                    #{id}
 
                </foreach>
 
            </if>
 
        </where>
 
    </select>
 
</mapper>

7.UserTest.java

package test;
 
import dao.UserDao;
 
import entity.UserVo;
 
import entity.Users;
 
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.After;
 
import org.junit.Before;
 
import org.junit.Test;
 
import java.io.IOException;
 
import java.io.InputStream;
 
import java.util.ArrayList;
 
import java.util.List;
 
public class UserTest {
 
    private InputStream in;
 
    private SqlSession sqlSession;
 
    private UserDao UserDaoImpl;
 
    @Before
 
    public void init() throws IOException {
 
        //1.读取配置文件
 
        in= Resources.getResourceAsStream("SqlMapperConfig.xml");
 
        //2.创建SqlSessionFactory工厂
 
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
 
        SqlSessionFactory factory=builder.build(in);
 
        //3.使用工厂生产SqlSession对象
 
        sqlSession=factory.openSession();
 
        //4.使用SqlSession创建dao接口的代理对象
 
        UserDaoImpl=sqlSession.getMapper(UserDao.class);
 
    }
 
    @After
 
    public void destroy() throws IOException {
 
        //提交事务
 
        sqlSession.commit();
 
        //6.释放资源
 
        sqlSession.close();
 
        in.close();
 
    }
 
    /**
 
     * 查询所有
 
     * @throws IOException
 
     */
 
    @Test
 
    public void findall() throws IOException {
 
        //5.使用代理对象执行方法
 
        List<Users> users=UserDaoImpl.findAll();
 
        for(Users u:users){
 
            System.out.println(u);
 
        }
 
    }
 
    /**
 
     * 根据ID进行查询
 
     */
 
    @Test
 
    public void find(){
 
       Users u=UserDaoImpl.find(15);
 
        System.out.println(u);
 
    }
 
    /**
 
     * 模糊查询，查询所有名字中有小的用户
 
     * @throws IOException
 
     */
 
    @Test
 
    public void findVague() throws IOException {
 
        //5.使用代理对象执行方法
 
        List<Users> users=UserDaoImpl.findVague("%小%");
 
        for(Users u:users){
 
            System.out.println(u);
 
        }
 
    }
 
    /**
 
     * 查询用户总数
 
     */
 
    @Test
 
    public void count(){
 
        int c=UserDaoImpl.count();
 
        System.out.println(c);
 
    }
 
    /**
 
     * 将实体类封装到另一个实体类中的模糊查询
 
     */
 
    @Test
 
    public void findVo(){
 
        UserVo vo=new UserVo();
 
        Users users=new Users();
 
        users.setUsername("%小%");
 
        vo.setUsers(users);
 
        List<Users> list=UserDaoImpl.findVo(vo);
 
        for(Users u:list){
 
            System.out.println(u);
 
        }
 
    }
 
    /**
 
     * if标签查询，查询用户名为小花，id为25的用户信息
 
     */
 
    @Test
 
    public void findby(){
 
        Users users=new Users();
 
        users.setUsername("小花");
 
        users.setId(25);
 
        Users u=UserDaoImpl.findby(users);
 
        System.out.println(u);
 
    }
 
    /**
 
     * 根据UserVo中的ids集合查询用户信息
 
     */
 
    @Test
 
    public void findids(){
 
        UserVo vo=new UserVo();
 
        List<Integer> list=new ArrayList<Integer>();
 
        list.add(13);
 
        list.add(14);
 
        list.add(15);
 
        vo.setIds(list);
 
        List<Users> li=UserDaoImpl.findids(vo);
 
        for(Users u:li){
 
            System.out.println(u);
 
        }
 
    }
 
}