mysql 动态表名 查询 动态mysql语句

持久层 Dao 映射配置

<?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.xinghua.dao.IUserDao">

    <!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    <resultMap id="userMap" type="com.xinghua.domain.User">
        <!-- 主键字段的对应 -->
        <id property="userId" column="id"></id>
        <!-- 非主键字段的对应 -->
        <result property="userNumber" column="number"></result>
        <result property="userName" column="username"></result>
        <result property="userPass" column="userpass"></result>
        <result property="userGender" column="gender"></result>
        <result property="userCreateDt" column="createDt"></result>
    </resultMap>

    <!-- 了解的内容：抽取重复的sql语句 -->
    <sql id="defaultUser">
        select * from test
    </sql>
    <!--配置查询所有-->

    <select id="findAll" resultMap="userMap">
        <include refid="defaultUser"></include>
    </select>

    
    <!-- 根据id查询用户信息 -->
    <select id="findById" parameterType="int" resultMap="userMap">
        select * from test where id = #{id};
    </select>
    
    <!-- 根据名称模糊查询用户信息 -->
    <select id="findByName" parameterType="string" resultMap="userMap">
        select * from test where username like #{value};
    </select>

    <!-- 根据queryVo中的条件查询用户 -->
    <select id="findUserByVo" parameterType="com.xinghua.domain.QueryVo" resultMap="userMap">
        select * from test where username like #{user.userName};
    </select>

    <!-- 根据条件查询 -->
    <!-- <select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from test where 1=1
        <if test="userName != null">
            and username = #{userName}
        </if>
        <if test="userGender != null">
            and gender = #{userGender}
        </if>
    </select> -->

    <select id="findUserByCondition" resultMap="userMap" parameterType="user">
        <include refid="defaultUser"></include>
        <where>
            <if test="userNumber != null">
                and number = #{userNumber}
            </if>
            <if test="userName != null">
                and username = #{userName}
            </if>
            <if test="userPass != null">
                and userpass = #{userPass}
            </if>
            <if test="userGender != null">
                and gender = #{userGender}
            </if>
        </where>
    </select>

    <!-- 根据queryvo中的Id集合实现查询用户列表 -->
    <select id="findUserInIds" resultMap="userMap" parameterType="queryvo">
        <include refid="defaultUser"></include>
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
            <!--<if test="userGender != null">-->
                <!--and gender = #{userGender}-->
            <!--</if>-->
        </where>
    </select>
</mapper>

注意：<if>标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。

另外要注意 where 1=1 的作用~！

为了简化上面 where 1=1 的条件拼装，我们可以采用<where>标签来简化开发

传入多个 id 查询用户信息，用下边两个 sql 实现：

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

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

这样我们在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。

SQL 语句：

select 字段 from user where id in (?)

<foreach>标签用于遍历集合，它的属性：

collection:代表要遍历的集合元素，注意编写时不要写#{}

open:代表语句的开始部分

close:代表结束部分

item:代表遍历集合的每个元素，生成的变量名

sperator:代表分隔符

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

在 QueryVo 中加入一个 List 集合用于封装参数

package com.xinghua.domain;

import java.util.List;

public class QueryVo {

    private User user;

    private List<Integer> ids;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }
}

编写测试方法

package com.xinghua.test;

import com.xinghua.dao.IUserDao;
import com.xinghua.domain.QueryVo;
import com.xinghua.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.After;
import org.junit.Before;
import org.junit.Test;

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

/**
 * mybatis的入门案例
 */
public class MybatisTest {

    private InputStream in;
    private SqlSession session;
    private IUserDao userDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        session = factory.openSession();
        //session = factory.openSession(true);
        //4.使用SqlSession创建Dao接口的代理对象
        userDao = session.getMapper(IUserDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        session.commit();
        //session.commit();
        //6.释放资源
        session.close();
        in.close();
    }
    /**
     * 入门案例 查询
     */
    @Test
    public void testFindAll(){

        //5.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for (User user : users){
            System.out.println(user);
        }

    }

    /**
     * 测试查询单个的方法
     */
    @Test
    public void testFindOne(){
        //5.执行查询单个的方法
        User user = userDao.findById(8);
        System.out.println(user);
    }

    /**
     * 测试模糊查询操作
     */
    @Test
    public void testFindName(){
        //5.执行模糊查询方法
        List<User> users = userDao.findByName("%王%");
//        List<User> users = userDao.findByName("王");
        for (User user : users){
            System.out.println(user);
        }
    }

    /**
     * 测试使用QueryVo作为查询条件
     */
    @Test
    public void testFindByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUserName("%王%");
        vo.setUser(user);
        //5.执行模糊查询方法
        List<User> users = userDao.findUserByVo(vo);
        for (User u : users){
            System.out.println(u);
        }
    }

    /**
     * 测试根据条件查询
     */
    @Test
    public void testFindByCondition(){
        User u = new User();
        u.setUserNumber("11230103");
        u.setUserName("王五");
        u.setUserGender("男");
        u.setUserPass("123456");
//        ArrayList<Integer> ids = new ArrayList<Integer>();
//        Collections.addAll(ids,1,2,3);
//        u.(ids);

        //5.执行查询所有方法
        List<User> users = userDao.findUserByCondition(u);
        for (User user : users){
            System.out.println(user);
        }
    }

    /**
     * 测试foreach标签的使用
     */
    @Test
    public void testFindInIds(){
        QueryVo vo = new QueryVo();
        List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(4);
        list.add(6);
        vo.setIds(list);
//        User u = new User();
//        u.setUserGender("男");
//        vo.setUser(u);

        //5.执行查询所有方法
        List<User> users = userDao.findUserInIds(vo);
        for (User user : users){
            System.out.println(user);
        }
    }
}

持久层 Dao 接口

package com.xinghua.dao;

import com.xinghua.domain.User;
import com.xinghua.domain.QueryVo;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有操作
     * @return
     */
    List<User> findAll();

    /**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

    /**
     * 根据名称模糊查询用户信息
     * @param username
     * @return
     */
    List<User> findByName(String username);

    /**
     *根据queryVo中的条件查询用户
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);

    /**
     * 根据传入参数条件
     * @param user 查询的条件：有可能有用户名，有可能有性别，也有可能有编号，还有可能都有
     * @return
     */
    List<User> findUserByCondition(User user);

    /**
     * 根据queryvo中提供的id集合，查询用户信息
     * @param vo
     * @return
     */
    List<User> findUserInIds(QueryVo vo);
}