mybatis-02

Mybatis第二天

1、MyBatis框架中的日志记录
MyBatis框架中，可以通过log4j实现日志输出。
显示MyBatis访问数据库的过程。如：执行的SQL，迭代的ResultSet等.
log4j是MyBatis框架必须依赖的插件jar包。
显示日志信息，必须通过log4j的配置文件：log4j.properties实现配置.
在资料中有配置文件模板.
log4j.properties日志配置文件，必须保持在classpath下.src或bin目录中
或者在mybatis总体配置文件里面开启mybatis日志
<!-- 开启mybatis的日志记录 -->
<settings>
　　<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

log4j.rootCategory=DEBUG, CONSOLE,LOGFILE


log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=-%p-%d{yyyy/MM/dd HH:mm:ss,SSS}-%l-%L-%m%n


log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=D:/axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=-%p-%d{yyyy/MM/dd HH:mm:ss,SSS}-%l-%L-%m%n

2、MyBatis框架中的参数
1：占位符
1.2 用途：相当于JDBC技术中SQL语法内的的 ?
1.2 语法：#{变量名}
1.3 位置：在MyBatis映射文件中定义. 编写在SQL语法中
1.4 参数传递特征：占位符命名大小写敏感.
1.5 简单类型：传递简单类型变量: 八种基本类型,对应封装类型，String，忽略占位符的个数和占位符变量的命名，将数据传递给所有的占位符。
1.6 Map集合对象：根据占位符的命名,作为Map中的Key,查询value. 将对象的数据,赋值给占位符.如果占位符命名在Map中不存在key, 参数数据为null.

2：拼接符
拼接符使用方式和占位符完全一致，传递参数的特性有区别。
拼接符不能传递简单类型变量。可以传递自定义对象或Map集合对象。
尽量避免使用拼接符，有SQL注入安全隐患。
2.1 用途：使用特定的语法,为映射文件中的SQL语句,实现动态字符串拼接. 
2.2 语法：${变量名}
2.3 位置：在MyBatis映射文件中定义. 编写在SQL语法中
占位符与拼接符的区别：
1：#是将传入的值当做字符串的形式，变量替换后，#{} 对应的变量自动加上单引号 
eg：select id,name,age from student where id =#{id}，当前端把id值1，传入到后台的时候，就相当于 select id,name,age from student where id ='1'
2：$是将传入的数据直接显示生成sql语句，变量替换后，${} 对应的变量不会加上单引号 
eg：select id,name,age from student where id =${id}，当前端把id值1，传入到后台的时候，就相当于 select id,name,age from student where id = 1
3：1）#{} 能防止sql 注入   
　  2）${} 不能防止sql 注入
4：但是如果使用在order by 中就需要使用 $
5：在大多数情况下还是经常使用#，但在不同情况下必须使用$
6：1）#{} 为参数占位符 ?，即sql 预编译   
　  2）${} 为字符串替换，即 sql 拼接
7：1）#{}：动态解析 -> 预编译 -> 执行       
　  2）${}：动态解析 -> 编译 -> 执行
#{} 和 ${} 在使用中的技巧和建议
（1）不论是单个参数，还是多个参数，一律都建议使用注解@Param("")
（2）能用 #{} 的地方就用 #{}，不用或少用 ${}
（3）表名作参数时，必须用 ${}。如：select * from ${tableName}
（4）order by 时，必须用 ${}。如：select * from t_user order by ${columnName}
3、MyBatis框架中的CUD(增删改)和事物的管理
MyBatis框架中,默认事务为rollback.(所有对数据库的操作，只有JDBC默认的自动提交)
在SqlSession对象回收的时候,自动回滚.
默认事务定义的位置:
SqlSessionFactory.openSession();调用的时候,设置的默认事务.底层调用的是 openSession(false);
SqlSessionFactory.openSession(boolean autoCommit);
含义: 为JDBC中的Connection设定自动提交参数. connection.setAutoCommit (autoCommit);
Mybatis具体实例增删改查+分页
pojo层和xml映射配置

package com.boom.pojo;

import java.io.Serializable;

/**
 * 实体对应的数据库表
 * @project_name mybatis-01 
 * @class_name User
 * @author Dilraba
 */
public class User implements Serializable {
    
    private Integer userid;//用户名ID
    private String username;//用户姓名
    private Integer userage;//用户年龄
    
    public Integer getUserid() {
        return userid;
    }
    public void setUserid(Integer userid) {
        this.userid = userid;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public Integer getUserage() {
        return userage;
    }
    public void setUserage(Integer userage) {
        this.userage = userage;
    }
    public User(Integer userid, String username, Integer userage) {
        super();
        this.userid = userid;
        this.username = username;
        this.userage = userage;
    }
    
    public User() {
        super();
    }
    
    @Override
    public String toString() {
        return "User [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
    }
    
}

<?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.boom.pojo.User">
    
    <select id="selectById" parameterType="int" resultType="com.boom.pojo.User">
        select * from user where userid = #{userid}
    </select>
    
    <!-- mybatis分页 -->
    <select id="selsectByAll"  resultType="com.boom.pojo.User">
        select * from user
    </select>
    
    <!-- 条件查询(多个参数查询,值绑定方式) -->
    <select id="selsectByNameAndAge"  resultType="com.boom.pojo.User">
        select * from user where username = #{username} and userage = #{userage}
    </select>

    <!-- 条件查询(map方式多个参数查询,将map的key绑定到占位符中) -->
    <select id="selsectByNameAndAgeMap" parameterType="map"  resultType="com.boom.pojo.User">
        select * from user where username = #{uname} and userage = #{uage}
    </select>
    
    <!-- selectMap 拿结果集的值作为map的key(key必须是结果集中存在的值) -->
    <select id="selsectByName" resultType="com.boom.pojo.User">
        select * from user
    </select>
    
    <!-- 添加操作 -->
    <insert id="insertUser" parameterType="com.boom.pojo.User" >
        insert into user(username,userage) values(#{username},#{userage})
    </insert>
    
    <!-- 更新 -->
    <update id="updateById">
        update user set username = #{username},userage = #{userage} where userid = #{userid}
    </update>
    
    <!-- 删除 -->
    <delete id="deleteById">
        delete from user where userid = #{userid}
    </delete>
    
</mapper>

数据库持久层

package com.boom.dao;

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

import com.boom.pojo.User;

public interface IUserDao {
    //根据ID查询单条的数据
    User selectById();
    
    //查询所有的数据分页显示
    List<User> selsectByAll();
    
    //条件查询(多个参数查询,值绑定方式)
    List<User> selsectByNameAndAge(User user);
    
    //条件查询(map方式多个参数查询,将map的key绑定到占位符中)
    List<User> selsectByNameAndAgeMap(Map<String, Object> map);
    
    //selectMap 拿结果集的值作为map的key(key必须是结果集中存在的值)
    List<User> selsectByName(String username);
    
    //添加操作
    void insertUser(User user);
    
    //更新
    void updateById(User user);
    
    //删除
    void deleteById(Integer userid);
}

package com.boom.dao.impl;

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

import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import com.boom.dao.IUserDao;
import com.boom.pojo.User;
import com.boom.util.MybatisUtil;

public class UserDaoImpl implements IUserDao {

    /**
     * 根据ID查询单条的数据
     */
    @Override
    public User selectById() {
        SqlSession session = MybatisUtil.openSession();
        return session.selectOne("selectById",4);
    }

    /**
     * 查询所有的数据分页显示
     */
    @Override
    public List<User> selsectByAll() {
        SqlSession session = MybatisUtil.openSession();
        //RowBounds(offset, limit)分页从下标0开始
        List<User> list = session.selectList("selsectByAll", null, new RowBounds(0,3));
        return list;
    }

    /**
     * 条件查询(多个参数查询,值绑定方式)
     */
    @Override
    public List<User> selsectByNameAndAge(User user) {
        SqlSession session = MybatisUtil.openSession();
        List<User> selectList = session.selectList("selsectByNameAndAge", user);
        return selectList;
    }
    
    /**
     * 条件查询(map方式多个参数查询,将map的key绑定到占位符中)
     */
    @Override
    public List<User> selsectByNameAndAgeMap(Map<String, Object> map) {
        SqlSession session = MybatisUtil.openSession();
        List<User> selectListMap = session.selectList("selsectByNameAndAgeMap", map);
        return selectListMap;
    }

    
    /**
     * selectMap 拿结果集的值作为map的key(key必须是结果集中存在的值)
     */
    @Override
    public List<User> selsectByName(String username) {
        SqlSession session = MybatisUtil.openSession();
        Map<String, Object> selectMap = session.selectMap("selsectByName", "username");
        System.out.println(selectMap);
        return null;
    }

    /**
     * 添加操作
     */
    @Override
    public void insertUser(User user) {
        SqlSession session = MybatisUtil.openSession();
        session.insert("insertUser", user);
        //手动提交事务
        session.commit();
    }

    /**
     * 更新
     */
    @Override
    public void updateById(User user) {
        SqlSession session = MybatisUtil.openSession();
        session.update("updateById", user);
        session.commit();
    }

    /**
     * 删除
     */
    @Override
    public void deleteById(Integer userid) {
        SqlSession session = MybatisUtil.openSession();
        session.delete("deleteById", userid);
        session.commit();
    }
    
    
}

工具类

package com.boom.util;

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 MybatisUtil {
    private static SqlSessionFactory factory = null;
    static{
        try {
            if(factory == null){
                //通过工具类加载配置文件，返回读取配置文件的IO流
                InputStream is = Resources.getResourceAsStream("mybatis-cfg.xml");
                //SqlSessionFactoryBuilder创建SqlSessionFactory对象的构建器
                factory = new SqlSessionFactoryBuilder().build(is);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取mybatis上下文对象
    public static SqlSessionFactory getSqlSessionFactory(){
        return factory;
    }
    //获取SqlSession
    public static SqlSession openSession(){
        return factory.openSession();
    }
}

测试类

package com.boom.test;

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

import com.boom.dao.IUserDao;
import com.boom.dao.impl.UserDaoImpl;
import com.boom.pojo.User;

public class MybatisTest {

    public static void main(String[] args) {
        
        //根据ID查询单条的数据
        IUserDao ud = new UserDaoImpl();
        System.out.println(ud.selectById());

        
        /*
        // 查询所有的数据分页显示
        IUserDao ud = new UserDaoImpl();
        List<User> userList = ud.selsectByAll();
        for (int i = 0; i < userList.size(); i++) {
            System.out.println(userList.get(i));
        }
        */
        
        /*
        //条件查询(多个参数查询)
        IUserDao ud = new UserDaoImpl();
        //创建User对象
        User u = new User();
        //将参数绑定通过user对象传递
        u.setUsername("张三");
        u.setUserage(18);
        List<User> userList = ud.selsectByNameAndAge(u);
        System.out.println(userList);
        */
        
        /*
        //条件查询(map方式多个参数查询,将map的key绑定到占位符中)
        IUserDao ud = new UserDaoImpl();
        //创建map对象
        Map<String , Object> map = new HashMap<>();
        map.put("uname", "张三");
        map.put("uage", 18);
        List<User> userList = ud.selsectByNameAndAgeMap(map);
        System.out.println(userList);
        */
        
        /*
        //selectMap 拿结果集的值作为map的key(key必须是结果集中存在的值)
        IUserDao ud = new UserDaoImpl();
        ud.selsectByName(null);
        */
        
        /*
        //添加
        IUserDao ud = new UserDaoImpl();
        //创建User对象
        User u = new User();
        u.setUsername("新增测试");
        u.setUserage(100);
        ud.insertUser(u);
        */
        
        /*
        //更新
        IUserDao ud = new UserDaoImpl();
        //创建User对象
        User u = new User();
        u.setUserid(9);
        u.setUsername("更新测试");
        u.setUserage(102);
        ud.updateById(u);
        */
        
        /*
        //删除
        IUserDao ud = new UserDaoImpl();
        ud.deleteById(5);
        */
        
    }  

}

总体架构图