mybatis 框架 的应用之二（批量添加、实现分页查询）

lf-driver=com.mysql.jdbc.Driver
lf-url=jdbc:mysql://localhost:3306/test
lf-user=LF
lf-password=LF

<?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="cn.zr.mybatis.mapper.HouseMapper">

    <!-- 数据库的表字段与实体类的属性之间的映射 -->
    <resultMap type="cn.zr.mybatis.entity.House" id="house">
        <id column="addr_city" property="city"/>
        <result column="addr_province" property="province"/>
        <result column="addr_country" property="country"/>
    </resultMap>
    <!-- 查询所有数据 -->
    <select id="getAllHouse" resultMap="house">
        SELECT
            addr_city,addr_province,addr_country
        FROM HOUSE
    </select>
</mapper>
  

<?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="cn.zr.mybatis.mapper.UserMapper">

    <!-- USERTEST 表的字段 -->
    <sql id="usertestColumns">
        NAME,AGE,ADDRESS
    </sql>

    <!-- 查询USERTEST的所有数据 -->
    <select id="getAllUser" resultType="cn.zr.mybatis.entity.User">
        SELECT <include refid="usertestColumns"/> FROM USERTEST
    </select>

    <!-- 通过字段来插入用户 -->
    <insert id="addUserByWords">
        INSERT INTO USERTEST(NAME,AGE,ADDRESS)
        VALUES(#{0},#{1},#{2})
    </insert>

    <!-- 插入用户 -->
    <insert id="addUser" parameterType="cn.zr.mybatis.entity.User">
        INSERT INTO USERTEST VALUES(#{name},#{age},#{address})
    </insert>

    <!-- 批量添加用户 -->
    <insert id="bacthUsers" parameterType="cn.zr.mybatis.entity.User">
        INSERT INTO USERTEST(<include refid="usertestColumns"/>) VALUES
        <foreach collection="list" item="val" separator=",">
            (#{val.name},#{val.age},#{val.address})
        </foreach>
    </insert>

    <!-- 模糊查询，并实现分页 -->
    <select id="queryUserByWord" parameterType="map" resultType="cn.zr.mybatis.entity.User">
        <if test="name != null">
            <!-- 给name拼接% -->
            <bind name="pattern" value=" '%'+name+'%' "/>
            SELECT <include refid="usertestColumns"/> FROM USERTEST
            <where>
                NAME LIKE #{pattern} ORDER BY NAME LIMIT #{star},#{size}
            </where>
        </if>
    </select>

    <!-- 在给定的区间内查询，并实现分页 -->
    <select id="queryUserInScope" parameterType="map" resultType="cn.zr.mybatis.entity.User">
        SELECT <include refid="usertestColumns"/> FROM USERTEST WHERE NAME IN
        <foreach collection="names" item="value" open="(" close=")" separator=",">
            #{value}
        </foreach>
        LIMIT #{stat},#{size}
    </select>

    <!-- 根据数组中的值进行查询 -->
    <select id="queryUserByNames" parameterType="java.lang.String" resultType="cn.zr.mybatis.entity.User">
        SELECT <include refid="usertestColumns"/> FROM USERTEST
        <where>
            NAME IN
            <foreach collection="array" item="val" open="(" close=")" separator=",">
                #{val}
            </foreach>
        </where>
    </select>

</mapper>
 

<?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>
    <properties resource="mybatis/config/db.properties"></properties>
    <!-- 配置环境 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置事务管理器的类型 -->
            <transactionManager type="JDBC"/>
            <!-- 配置数据源相关的属性 -->
            <dataSource type="UNPOOLED">
                <property name="driver" value="${lf-driver}"/>
                <property name="url" value="${lf-url}"/>
                <property name="username" value="${lf-user}"/>
                <property name="password" value="${lf-password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--END 配置环境 -->

    <!-- 配置映射路径 -->
    <mappers>
        <mapper resource="mybatis/config/mapper/UserMapper.xml"/>
        <mapper resource="mybatis/config/mapper/HouseMapper.xml"/>
    </mappers>
    <!-- END 配置映射路径 -->

</configuration> 

package cn.zr.mybatis.entity;

public class House {

    private String country;//国家
    private String province;//省份
    private String city;//城市
    public String getCountry() {
        return country;
    }
    public void setCountry(String country) {
        this.country = country;
    }
    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public House() {
        super();
    }
    public House(String country, String province, String city) {
        super();
        this.country = country;
        this.province = province;
        this.city = city;
    }
    @Override
    public String toString() {
        return "Address [country=" + country + ", province=" + province
                + ", city=" + city + "]";
    }

}

package cn.zr.mybatis.entity;

public class User {

    private String name;
    private Integer age;
    private String address;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public User() {
        super();
    }
    public User(String name, Integer age, String address) {
        super();
        this.name = name;
        this.age = age;
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", address=" + address
                + "]";
    }

}

package cn.zr.mybatis.mapper;

import java.util.List;

import cn.zr.mybatis.entity.User;

public interface HouseMapper {

    /**
     * 查询
     * @return 返回相关的房子数据
     */
    List<User> getAllHouse();

}

package cn.zr.mybatis.mapper;

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

import cn.zr.mybatis.entity.User;

public interface UserMapper {

    /**
     *  获取所有数据
     */
    public List<User> getAllUser();

    /**
     * 通过字段插入插入用户
     * @param name 用户名
     * @param age    年龄
     * @param address 地址
     * @return 返回成功插入数据的数量
     */
    public int addUserByWords(String name, int age, String address);

    /**
     * 插入数据
     * @param user 被插入的用户
     * @return 返回成功插入数据的数量
     */
    public int addUser(User user);

    /**
     * 批量添加用户
     * @param list 集合（存储User对象）
     * @return 返回成功插入数据的数量
     */
    public int bacthUsers(List<User> list);

    /**
     * 模糊查询，并实现分页
     * @param map 键值对（存着起始位置，每页的数量，以及模糊查询的数量）
     * @return 返回相关的用户数据
     */
    public List<User> queryUserByWord(Map<String, Object> map);

    /**
     * 在某个区间内查询，并实现分页
     * @param map键值对（存着起始位置，每页的数量，以及区间的范围）
     * @return 返回相关的用户数据
     */
    public List<User> queryUserInScope(Map<String, Object> map);

    /**
     * 通过数组中的值作为区间进行查询操作
     * @param names 区间的值
     * @return 返回相关的用户数据
     */
    public List<User> queryUserByNames(String[] names);

}

package cn.zr.mybatis.service;

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

import cn.zr.mybatis.entity.User;

public interface UserService {

    /**
     * 获取所有的用户信息
     */
    List<User> getAllUser();

    /**
     * 插入用户
     * @param name 用户名
     * @param age    年龄
     * @param address 地址
     * @return 返回成功插入数据的数量
     */
    int addUserByWords(String name, int age, String address);

    /**
     * 插入数据
     * @param user 被插入的用户
     * @return 返回成功插入数据的数量
     */
    int addUser(User user);

    /**
     * 批量添加用户
     * @param list 集合（存储User对象）
     * @return 返回成功插入数据的数量
     */
    int bacthUsers(List<User> list);

    /**
     * 模糊查询，并实现分页
     * @param map 键值对（存着起始位置，每页的数量，以及模糊查询的数量）
     * @return 返回相关的用户数据
     */
    List<User> queryUserByWord(Map<String, Object> map);

    /**
     * 在某个区间内查询，并实现分页
     * @param map键值对（存着起始位置，每页的数量，以及区间的范围）
     * @return 返回相关的用户数据
     */
    List<User> queryUserInScope(Map<String, Object> map);

    /**
     * 通过数组中的值作为区间进行查询操作
     * @param names 区间的值
     * @return 返回相关的用户数据
     */
    List<User> queryUserByNames(String[] names);

    /**
     * 查询
     * @return 返回相关的房子数据
     */
    List<User> getAllHouse();

}

package cn.zr.mybatis.service.impl;

import java.io.IOException;
import java.io.Reader;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionManager;

import cn.zr.mybatis.entity.User;
import cn.zr.mybatis.mapper.HouseMapper;
import cn.zr.mybatis.mapper.UserMapper;
import cn.zr.mybatis.service.UserService;

public class UserServiceImpl implements UserService{

    private static SqlSessionManager manager;
    private UserMapper userMapper;
    private HouseMapper houseMapper;

    {
        // 配置文件的路径
        String resource = "mybatis/config/mybatis-config.xml";
        try {
            // 将配置文件读取进来
            Reader reader = Resources.getResourceAsReader(resource);
            // 根据读取进来的配置文件创建SqlSessionManager对象
            manager = SqlSessionManager.newInstance(reader);
            //创建映射关系
            userMapper = manager.getMapper(UserMapper.class);
            //创建映射关系
            houseMapper = manager.getMapper(HouseMapper.class);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public List<User> getAllUser() {
        //userMapper调用接口的相关方法
        return userMapper.getAllUser();
    }

    @Override
    public int addUserByWords(String name, int age, String address) {
        return userMapper.addUserByWords(name,age,address);
    }

    @Override
    public int addUser(User user) {
        return userMapper.addUser(user);
    }

    @Override
    public int bacthUsers(List<User> list) {
        return userMapper.bacthUsers(list);
    }

    @Override
    public List<User> queryUserByWord(Map<String, Object> map) {
        return userMapper.queryUserByWord(map);
    }

    @Override
    public List<User> queryUserInScope(Map<String, Object> map) {
        return userMapper.queryUserInScope(map);
    }

    @Override
    public List<User> queryUserByNames(String[] names) {
        return userMapper.queryUserByNames(names);
    }

    @Override
    public List<User> getAllHouse() {
        return houseMapper.getAllHouse();
    }

}

package cn.zr.mybatis.test;

import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionManager;
import org.junit.Before;
import org.junit.Test;

import cn.zr.mybatis.entity.House;
import cn.zr.mybatis.entity.User;
import cn.zr.mybatis.mapper.UserMapper;
import cn.zr.mybatis.service.UserService;
import cn.zr.mybatis.service.impl.UserServiceImpl;
/**
 *
 * @author lf
 * 2017年2月13日
 * 通过接口调用相关方法
 */
public class TestMybatis {

//    public static void main(String[] args) {
//        TestMybatis testMybatis = new TestMybatis();
//        testMybatis.addUserAndAddress();
//
//    }

    private SqlSessionManager manager;
    private UserService userService;

    {
        //创建实现类
        userService = new UserServiceImpl();
    }
    /**
     * 获取所有数据
     */
    @Test
    public void getAllData() {

        // 调用相关方法
        List<User> list = userService.getAllUser();;

        System.out.println(list);
    }

    /**
     * 通过字段来添加用户
     */
    @Test
    public void addUserByWords() {
        int count = userService.addUserByWords("lffff",18,"beijing");
        if (count > 0) {
            System.out.println("成功插入"+count+"条数据");
        }else {
            System.out.println("插入操作失败");
        }
    }

    /**
     * 添加用户
     */
    @Test
    public void addUser () {
        User user = new User("dew",18,"hubei");
        int count = userService.addUser(user);
        if (count > 0) {
            System.out.println("成功插入"+count+"条数据");
        }else {
            System.out.println("插入操作失败");
        }
    }

    /**
     * 批量增加用户
     */
    @Test
    public void bacthUsers(){
        // 创建list
        List<User> list = new ArrayList<User>();
        list.add(new User("asd", 23, "China"));
        list.add(new User("ad", 23, "China"));
        list.add(new User("asddd", 23, "China"));
        list.add(new User("aswwd", 23, "China"));
        list.add(new User("asqwqd", 23, "China"));

        int count = userService.bacthUsers(list);
        if (count > 0) {
            System.out.println("成功插入"+count+"条数据");
        }else {
            System.out.println("插入操作失败");
        }
    }

    /**
     * 模糊查询，并实现分页效果
     */
    @Test
    public void queryUserByWord() {
        int star = 0;// 起始位置
        int size = 3;// 每页的条数
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("star", star);
        map.put("size", size);
        map.put("name", "a");

        List<User> list = userService.queryUserByWord(map);
        if (list.size() > 0) {
            System.out.println(list);
        }else {
            System.out.println("操作失败");
        }
    }

    /**
     * 区间分页查询
     */
    @Test
    public void queryUserInScope() {
        // 创建list
        List<String> list = new ArrayList<String>();
        list.add("asd");
        list.add("ad");
        list.add("asddd");
        list.add("aswwd");
        list.add("asqwqd");
        int stat = 1;//起始位置
        int size = 3;//每页显示的数量
        //创建Map
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("stat", stat);
        map.put("size", size);
        map.put("names", list);

        List<User> reseultList = userService.queryUserInScope(map);
        if (reseultList.size() > 0) {
            System.out.println(reseultList);
        }else {
            System.out.println("操作失败");
        }
    }

    /**
     * 通过数组中的值作为区间取查询
     */
    @Test
    public void queryUserByNames() {

        String[] names = {"asddd","aswwd","asqwqd"};
        List<User> list = userService.queryUserByNames(names);
        if (list.size() > 0) {
            System.out.println(list);
        }else {
            System.out.println("操作失败");
        }
    }

    /**
     * 查询所有数据
     */
    @Test
    public void getAllHouse(){
        List<User> list = userService.getAllHouse();
        if (list.size() > 0) {
            System.out.println(list);
        }else {
            System.out.println("操作失败");
        }
    }

}