mybatis

1、mybatis配置:SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。

mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

 2、通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂

 3、由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。

4.从mybatis的jar包结构可知mybatis用的是log4j记录日志，所以log4j.properties文件内容如下：

 

# Global logging configuration

#在开发的环境下，日志级别要设置成DEBUG，生产环境设置成info或error

log4j.rootLogger=DEBUG, stdout

# Console output...

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

 

1.parameterType和resultType

　　parameterType:在映射文件中通过parameterType指定输入 参数的类型。

　　resultType:在映射文件中通过resultType指定输出结果的类型

 2.#{}和${}

#{}表示一个占位符号，#{}接收输入参数，类型可以是简单类型，pojo、hashmap;

如果接收简单类型，#{}中可以写成value或其它名称;

#{}接收pojo对象值，通过OGNL读取对象中的属性值，通过属性.属性.属性...的方式获取对象属性值。

表示一个拼接符号，会引用sql注入，所以不建议使用表示一个拼接符号，会引用sql注入，所以不建议使用{}；

${}接收输入参数，类型可以是简单类型，pojo、hashmap;

如果接收简单类型，${}中只能写成value;

${}接收pojo对象值，通过OGNL读取对象中的属性值，通过属性.属性.属性...的方式获取对象属性值。

3.selectOne()和selectList()

　　selectOne表示查询出一条记录进行映射。如果使用selectOne可以实现使用selectList也可以实现（list中只有一个对象）。

　　selectList表示查询出一个列表（多条记录）进行映射。如果使用selectList查询多条记录，不能使用selectOne。

SqlMapConfig.xml

<?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>
 <!-- 次属性可以指定类的全路径，同时给他一个别名  相当于（id="'class=""）
     <typeAliases >
         <typeAlias type="com.mybatis.entry.userMapper" alias="umapper"/>
     </typeAliases>
 -->     
     <!-- 默认创建此工厂 默认模式 和spring整合后 environments配置将废除-->
     <environments default="development">
         <environment id="development">
<!-- 使用jdbc事务管理,事务控制由mybatis管理-->
             <transactionManager type="JDBC" />
             <!-- 配置数据库连接信息, 数据库连接池,由mybatis管理 -->
             <dataSource type="POOLED">
                 <property name="driver" value="com.mysql.jdbc.Driver" />
                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
                 <property name="username" value="root" />
                 <property name="password" value="root" />
             </dataSource>
         </environment>
     </environments>  
    <!-- 加载映射文件 -->
     <mappers>
         <!-- 注册userMapper.xml文件， 
         userMapper.xml位于com/mybatis/entry这个包下，
                       所以resource写成com/mybatis/entry/userMapper.xml
         -->
         <mapper resource="com/mybatis/entry/userMapper.xml"/>
     </mappers>
 </configuration>

mapper.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">

<!-- namespace命名空间,作用就是对sql进行分类化的管理,理解为sql隔离
    注意:使用mapper代理开发时，namespace有特殊作用
 -->

 <!--  <mapper namespace = "umapper">   -->
<mapper namespace = "com.mybatis.entry.userMapper">
<!-- 通过SELECT执行数据库查询 
    id:标识映射文件中的sql，称为statement的id;
        将sql语句封装在mapperStatement的对象中，所以Id称为Statement的id;
    parameterType:指定输入参数的类型,这里指定int型
    #{}:表示一个占位符;
    #{id}:其中Id表示接收输入的参数，参数名称就是Id,如果输入参数是简单类型，#{}中的参数名可以任意，可以是value或者其它名称;
    resultType:指定sql输出结果所映射的java对象类型,select指定resultType表示将单条记录映射成java对象。
-->

    <select id = "getUser" parameterType="int" resultType="com.mybatis.entry.User">
        select * from users where id=#{id}
    </select>
<!-- 根据用户名称模糊查询用户信息,可能返回多条数据
    resultType:指定的就是单条记录所映射的java类型;
    ${}:表示拼接sql字符串，将接收到的参数内容不加任何修饰拼接在sql中.
    使用${}拼接sql，可能会引起sql注入
    ${value}:接收输入参数的内容，如果传入的是简单类型,${}中只能使用value
 -->

    <select id = "nameLike" parameterType="java.lang.String" resultType="com.mybatis.entry.User">
        select * from users where name like '${value}%'
    </select>
    <insert id="insert" parameterType="com.mybatis.entry.User">
        insert into users (name,password) values (#{name},#{password})
    </insert>
    <delete id="delete" parameterType="int">
        delete from users where id = #{id}
    </delete>
    <update id="update">
        update users set name=#{name},password=#{password} where id = #{id}
    </update>
</mapper>

UserDAO.java

package com.mybatis.dao;

import java.io.InputStream;
import java.util.List;
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 com.mybatis.entry.User;

public class UserDAO {
    
    public User selectById(int id) throws Exception{
        //读取配置文件, // conf.xml:mybatis的配置文件
        InputStream in = Resources.getResourceAsStream("conf.xml");
        // 1.创建会话工场,传入mybatis的配置文件信息。通过配置文件 获得工厂对象（还可以指定使用那个数据源）
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 2.通过工厂得到SqlSession。获取一个 会话
        SqlSession session = factory.openSession();
        
        /* 3.通过sqlSession操作数据库
         *    第一个参数：映射文件中的statement的Id,等于namespace + "." + statement的id;
         *    第二个参数:指定和映射文件中所匹配的parameterType类型的参数;
         *    sqlSession.selectOne结果是与映射文件所匹配的resultType类型的对象;
         **/
        // selectOne：查询一条结果
        User user = session.selectOne("getUser",id);
        return user;
    }
    
    public List<User> selectByNameLike(String s) throws Exception {
        InputStream in = Resources.getResourceAsStream("conf.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        
        List<User> list = session.selectList("nameLike",s);
        
        return list;
    }
    
    public void insert(User user) throws Exception {
        InputStream in = Resources.getResourceAsStream("conf.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        
        session.insert("insert",user);
        session.commit();
        session.close();
    }
    
    public void delete(int id) throws Exception {
        InputStream in = Resources.getResourceAsStream("conf.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        
        session.delete("delete",id);
        session.commit();
        session.close();
    }
    
    public void update(User user) throws Exception{
        InputStream in = Resources.getResourceAsStream("conf.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        
        session.update("update",user);
        session.commit();
        session.close();
    }
    
}

User.java

package com.mybatis.entry;

public class User {
     // 属性名称和数据库字段名称保持一致
    private Integer id;
    private String name;
    private String password;

    public User() {
        super();
    }

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public User(Integer id, String name, String password) {
        super();
        this.id = id;
        this.name = name;
        this.password = password;
    }

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", password=" + password + "]";
    }
    
    
}

Test.java

package com.mybatis.service;

import java.util.List;
import org.junit.Test;
import com.mybatis.dao.UserDAO;
import com.mybatis.entry.User;

public class UserService {
    
    @Test  
    public void testSelectById() throws Exception{
        UserDAO userDao = new UserDAO();
        User user = userDao.selectById(1);
        System.out.println("通过id查询");
        System.out.println(user);
    }
    
    @Test  
    public void testNameLike() throws Exception{
        UserDAO userDao = new UserDAO();
        List<User> list = userDao.selectByNameLike("刘");
        System.out.println("通过名字模糊查询");
        for(User u:list){
            System.out.println(u);
        }
    }
    
    @Test  
    public void testInser() throws Exception{
        UserDAO userDao = new UserDAO();
        User user = new User("王老师","123");
        userDao.insert(user);
        System.out.println("插入成功");
    }
    
    @Test 
    public void testDelete() throws Exception{
        UserDAO userDao = new UserDAO();
        userDao.delete(10);
        System.out.println("删除成功");
    }
    
    @Test
    public void testUpdate() throws Exception{
        UserDAO userDao = new UserDAO();
        User user = new User(10,"呃呃","123");
        userDao.update(user);
        System.out.println("更新成功");
    }
    
    @Test
    public void testUpdatePass() throws Exception{
        UserDAO userDao = new UserDAO();
        User userSe = userDao.selectById(10);
        System.out.println(userSe);

        User user = new User(userSe.getId(),userSe.getName(),"321");
        userDao.update(user);
        System.out.println("更新password成功");
    }
    
}