MyBatis学习（二）

代理Dao方式的CRUD操作

代理Dao方式的增删改查

1. 创建项目
2. UserDao接口代码

package com.qcby.dao;

import com.qcby.entity.User;
import java.util.List;

public interface UserDao {
    /**
     * 查询所有用户
     */
    public List<User> findAll();

    /**
     * 通过id查询一条数据
     * @param id
     * @return
     */
    public User findById(int id);

    /**
     * 增加数据
     * @param user
     * @return
     */
    public int insert(User user);

    /**
     * 更新数据
     * @param user
     */
    public int update(User user);

    /**
     * 删除数据
     * @param user
     */
    public int delete(int id);
}

3. UserDao.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.qcby.dao.UserDao">
<!--通过id查询 SQL语句使用#{占位符的名称，名称可以任意}，仅限于基本数据类型和String类型-->
<select id="findAll" resultType="com.qcby.entity.User">
        select * from user
    </select>
<!-- 根据ID查询一条数据-->
<select id="findById" parameterType="int" resultType="com.qcby.entity.User">
        select * from user where id = #{id}
    </select>
<insert id="insert" parameterType="com.qcby.entity.User">
    /*查询ID
    keyProperty:封装数据到属性
    order:数据添加后的操作
    resulType:数据类型
    */
    <selectKey order="AFTER" resultType="int" keyProperty="id">
        select last_insert_id();
    </selectKey>
    insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>
<update id="update" parameterType="com.qcby.entity.User">
        update user set username = #{username},birthday = #{birthday},sex = #{sex},address = #{address} where id = #{id}
    </update>
<delete id="delete" parameterType="int">
        delete from user where id = #{id}
    </delete>
<select id="findByUserName" parameterType="String" resultType="com.qcby.entity.User">
        select * from user where username like #{username}
    </select>
    
    <!--<select id="findByUserName" parameterType="String" resultType="com.qcby.entity.User">
    select * from user where username like '%${value}%'
</select>-->
<select id="findCount" resultType="int">
        select count(* )from user
    </select>
</mapper>

4. UserTest的代码
   ps：修改数据（包括添加、删除、修改数据），如果数据库事务管理，使用JDBC本地策略，则需要手动提交事务，否则，数据库中数据无法修改

package com.qcby.test;

import com.qcby.dao.UserDao;
import com.qcby.entity.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.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

public class UserTest {
    private InputStream in = null;
    private SqlSession session = null;
    private UserDao mapper = null;

    @Before
    public void init() throws IOException {
        //加载主配置文件，目的是为了构建SqlSessionFactory对象
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //通过SqlSessionFactory工厂对象创建SqlSesssion对象
        session = factory.openSession();
        //通过Session创建UserDao接口代理对象
        mapper = session.getMapper(UserDao.class);
    }
    @After
    public void destory() throws IOException {
        //释放资源
        session.close();
        in.close();
    }

    /**
     * 测试查询所有的方法
     */
    @Test
    public void run() throws IOException {
       /* //加载主配置文件，目的是为了构建SqlSessionFactory对象
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //通过SqlSessionFactory工厂对象创建SqlSesssion对象
        SqlSession session = factory.openSession();
        //调用查询所有的方法
        List<User> list = session.selectList("com.qcby.dao.UserDao.findAll");
        //遍历集合
        for (User user : list) {
            System.out.println(user);
        }
        //释放资源
        session.close();
        in.close();*/
    }
    /**
     * 测试查询所有的方法
     */
    @Test
    public void testFindAll() {

        //调用查询所有的方法
        List<User> list = mapper.findAll();
        for (User user : list) {
            System.out.println(user);
        }
    }

    /**
     * 测试
     */
    @Test
    public void testFindById() throws IOException {

        //调用查询ID的方法
        User user = mapper.findById(2);
        System.out.println(user);

    }
    /**
     * 测试增加
     */
    @Test
    public void testInsert() throws IOException {

        //创建user对象
        User user = new User();
        user.setUsername("guos");
        user.setSex("男");
        user.setBirthday(new Date());
        user.setAddress("背景");

        //调用添加方法
        int result = mapper.insert(user);
        session.commit();
        System.out.println(user.getId());
        System.out.println(result);

    }
    /**
     * 测试更新
     */
    @Test
    public void testUpdate() throws IOException {

        //创建user对象
        User user = new User();
        user.setId(4);
        user.setUsername("小花");
        user.setSex("女");
        user.setBirthday(new Date());
        user.setAddress("北京");

        //调用更新
        int result = mapper.update(user);
        session.commit();
        System.out.println(result);
    }

    /**
     * 测试删除
     */
    @Test
    public void testDelete() {
        //调用删除
        int result = mapper.delete(7);
        session.commit();
        System.out.println(result);
    }
    /**
     * 测试模糊查询
     */
    @Test
    public void testfindByUserName(){
        //调用查询数量
        List<User> list = mapper.findByUserName("%熊%");
        session.commit();
        for (User user : list) {
            System.out.println(user);
        }
    }

    /**
     * 测试数量
     */
    @Test
    public void testfindCount(){
        //调用查询数量
        int count = mapper.findCount();
        session.commit();
        System.out.println(count);
    }
}

5. 模糊查询符号使用的区别${},#{}

#{} 参数是采用预编译 防止sql注入

${}参数是采用sql拼接 无法防止sql注入


#{} 参数是简单类型 （基础类型和字符串），变量可以任意

${} 参数是简单类型 （基础类型和字符串），变量必须是value


#{} 参数是引用类型，变量是引用类型中的属性，不可任意

${} 参数是引用类型 ，变量是引用类型中的属性，不可任意