MyBatis泛览一(基本配置和查询)

2019-02-23 本文已影响3人强某某

MyBatis

parameterType和resultType

parameterType：指定输入参数的java类型，可以填写别名或Java类的全限定名
resultType:指定输出结果的java类型，可以填写别名或Java类的全限定名

#{}和${}

{}：相当于预处理中的占位符？。

{}里面的参数表示接收java输入参数的名称。

{}可以接受HashMap、POJO类型的参数。

当接受简单类型的参数时，#{}里面可以是value，也可以是其他。

{}可以防止SQL注入。
${}：相当于拼接SQL串，对传入的值不做任何解释的原样输出。

${}会引起SQL注入，所以要谨慎使用。

${}可以接受HashMap、POJO类型的参数。

当接受简单类型的参数时，${}里面只能是value。

selectOne和selectList

selectOne：只能查询0或1条记录，大于1条记录的话，会报错：
selectList：可以查询0或N条记录

Mybatis基本步骤

添加依赖包

依赖包.png

添加log4j.properties(mybatis日志包是log4j)

# Global logging configuration
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

> 日志级别在开发阶段设置成DEBUG，在生产阶段设置成INFO或者ERROR

书写全局的配置文件

SqlMapConfig.xml:在src目录下
<?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>
    <!--此时识别的是src目录下的文件-->
    <properties resource="db.properties"/>
    <!--配置别名-->
    <typeAliases>
        <!--方式一-->
        <!--<typeAlias type="com.zengqiang.model.User" alias="user"></typeAlias>-->
        <!--方式二-->
        <!--指定包名，别名就是类名并且第一个字母小写  例如 User 别名就是user-->
        <package name="com.zengqiang.model"></package>
        <package name="com.zengqiang.vo"></package>
    </typeAliases>
    <!-- 配置mybatis的环境信息 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用dbcp连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="${driverClass}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${name}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--告诉mybatis加载映射文件-->
    <mappers>
        <!--<mapper resource="com/zengqiang/sqlmap/User.xml"></mapper>-->
        <!--第一种:写映射文件的名字-->
        <!--<mapper resource="com/zengqiang/mapper/UserMapper.xml"></mapper>-->
        <!--第二种:写类名,此种方法一定要有个映射文件与之对应
        如果没有，那么在UserMapper接口中要声明注解-->
        <!--<mapper class="com.zengqiang.mapper.UserMapper"></mapper>-->
        <!--第三种：可以写包名,很方便-->
        <package name="com.zengqiang.mapper"></package>
    </mappers>
</configuration>

数据库信息文件

db.properties:在src目录下
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatisday1?useUnicode=true&amp;characterEncoding=utf8
name=root
password=123456

简化案例(不分层，只使用)

在com.zengqiang包下创建文件夹sqlmap(名称随意),然后创建User.xml文件
在com.zengqiang包下创建文件夹dao(名称随意),然后创建User.java文件

User.java
public class User implements Serializable {
    private int id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址

    public User() {
    }

    public User(String username, String sex, Date birthday, String address) {
        this.username = username;
        this.sex = sex;
        this.birthday = birthday;
        this.address = address;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + ", birthday=" + birthday + ", address=" + address + "]";
    }
}

User.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:命名空间，值一般按照对应statement的类名即可，没有必然对应关系-->
<mapper namespace="user">
    <!--根据id查询-->
    <!--
    [id]：statement的id，要求在命名空间内唯一
    [parameterType]：入参的java类型
    [resultType]：查询出的单条结果集对应的java类型
    [#{}]： 表示一个占位符?
    [#{id}]：表示该占位符待接收参数的名称为id。
    注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
 -->
    <select id="findUserById" parameterType="int" resultType="com.zengqiang.model.User">
        SELECT * FROM user WHERE id = #{id}
    </select>

    <!--
             [${}]：表示拼接SQL字符串
             [${value}]：表示要拼接的是简单类型参数。
             注意：
             简单类型:int,byte,... string
            1、如果参数为简单类型时，${}里面的参数名称必须为value
            2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}
      -->
    <select id="findUserByName" parameterType="String" resultType="com.zengqiang.model.User">
        SELECT * FROM user WHERE username LIKE '%${value}%'
--         SELECT * FROM user WHERE username LIKE '%"#{value}"%'
    </select>

    <!--插入数据
        这里的占位是写模型的属性
    -->
    <insert id="insertUser" parameterType="com.zengqiang.model.User">
        INSERT INTO user (username,sex,birthday,address)
        VALUE (#{username},#{sex},#{birthday},#{address});
    </insert>

    <!--删除-->
    <delete id="deleteUser" parameterType="int">
        DELETE FROM user where id = #{id};
    </delete>
    <!--更新-->
    <update id="updateUser" parameterType="com.zengqiang.model.User">
        UPDATE user SET address = #{address},sex = #{sex}
        WHERE id = #{id}
    </update>
    <!--插入时自动返回主键id-->
    <insert id="insertUser2" parameterType="com.zengqiang.model.User">
        <!--
            [selectKey标签]：通过select查询来生成主键
            [keyProperty]：指定存放生成主键的属性
            [resultType]：生成主键所对应的Java类型
            [order]：指定该查询主键SQL语句的执行顺序，相对于insert语句
            [last_insert_id]：MySQL的函数，要配合insert语句一起使用

            下面也可以：SELECT UUID()，然后返回mysql自增的UUID
        -->
        <selectKey keyProperty="id" resultType="int" order="AFTER">
            SELECT LAST_INSERT_ID()
        </selectKey>
        INSERT INTO user (username,sex,birthday,address)
        VALUE (#{username},#{sex},#{birthday},#{address});
    </insert>
</mapper>

单元测试类:注意增删改都需要提交事务(commit)，然后close，但是查找直接close即可
public class Demo{
    SqlSession session;
    @Before
    public void before() throws IOException {
        System.out.println("before.....获取session");
        //a)读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

        // c)通过SqlSessionFactory创建SqlSession。
        session = sessionFactory.openSession();
    }

    @After
    public void after(){
        System.out.println("after.....关闭session");
//        关闭SqlSession。
        session.close();
    }

    /**
     * 查询：一条记录和多条记录
     * @throws IOException
     */
    @Test
    public void test1() throws IOException {
        //查询一条结果,其中findUserById对应User.xml中的statement的id
        User user = session.selectOne("findUserById",10);
        System.out.println(user);

        //查询多条结果
        List<User> users = session.selectList("findUserByName","张");
        System.out.println(users);
    }


    /**
     * 插入数据
     * @throws IOException
     */
    @Test
    public void test2() throws IOException {
       User user = new User("zengqiang04","2",new Date(),"广州");
       int affectRow = session.insert("insertUser",user);
       session.commit();//事务
        System.out.println("受影响的行数:" + affectRow);
    }
    //删除用户
    @Test
    public void test3() throws IOException {
       int affectRow = session.delete("deleteUser",27);
       session.commit();//事务
       System.out.println("受影响的行数:" + affectRow);
    }

    //更新用户
    @Test
    public void test4() throws IOException {
        User user = new  User();
        user.setId(32);
        user.setSex("男");
        user.setAddress("深圳");
        int affectRow = session.update("updateUser",user);
        session.commit();//事务
        System.out.println("受影响的行数:" + affectRow);
    }


    /**
     * 插入后，往模型里设置id
     * @throws IOException
     */
    @Test
    public void test5() throws IOException {
        User user = new User("zengqiang05","2",new Date(),"广州");
        int affectRow = session.insert("insertUser2",user);
        session.commit();//事务
        System.out.println("受影响的行数:" + affectRow);
        System.out.println("用户的ID:" + user.getId());
    }

}

分Dao层(手写实现类，不常用)

在com.zengqiang包下建立dao文件夹
在该文件夹下面创建UserDao接口
在该文件夹下面创建UserDaoImpl.java文件

public interface UserDao {

    /**
     * 保存一个用户
     * @param user
     */
    public void save(User user);

    public User findUserById(int id);
}

public class UserDaoImpl implements UserDao {

    private SqlSessionFactory ssf;

    public UserDaoImpl() {
    }

    public UserDaoImpl(SqlSessionFactory ssf) {
        this.ssf = ssf;
    }

    @Override
    public void save(User user) {
        //获取session
        SqlSession session = ssf.openSession();
        //插入数据
        session.insert("insertUser",user);
        session.commit();
        session.close();
    }

    @Override
    public User findUserById(int id) {
        //获取session
        SqlSession session = ssf.openSession();
        //插入数据
        User user = session.selectOne("findUserById",id);
        session.close();
        return user;
    }
}

说明：该种方式也需要有个User.xml文件

单元测试类:
public class Demo {
    SqlSessionFactory sessionFactory;
    @Before
    public void before() throws IOException {
        System.out.println("before.....获取session");
//        a)读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");

        //b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
        sessionFactory = new SqlSessionFactoryBuilder().build(is);

    }
    @Test
    public void test1() throws IOException {
        //调用dao
        //1.创建dao
        UserDao userDao = new UserDaoImpl(sessionFactory);
        User user1 =  userDao.findUserById(1);
        System.out.println(user1);
        User user2 = new User("xxx","x",new Date(),"xx");
        userDao.save(user2);
    }
}

Spring自动生成实现类(常用)

Mapper代理的开发方式，程序员只需要编写mapper接口（相当于dao接口）即可。Mybatis会自动的为mapper接口生成动态代理实现类。
不过要实现mapper代理的开发方式，需要遵循一些开发规范

mapper接口的全限定名要和mapper映射文件的namespace的值相同。
mapper接口的方法名称要和mapper映射文件中的statement的id相同；
mapper接口的方法参数只能有一个，且类型要和mapper映射文件中statement的parameterType的值保持一致。
mapper接口的返回值类型要和mapper映射文件中statement的resultType值或resultMap中的type值保持一致；

自动映射关系.png

步骤

在com.zengqiang包下新建mapper文件夹(名字必须固定)
该包下创建UserMapper(命名一般对应dao下面的文件，此时对应User.java)
创建UserMapper.xml

UserMapper.java
public interface UserMapper {

    /**
     *
     * @param user
     * @return 受影响的行数
     */
//此处对应SqlMapConfig.xml种说的，如果不添加UserMapper.xml文件则通过注解也可，但是不常用
    //@Insert("INSERT INTO user (username,sex,birthday,address) VALUE (#{username},#{sex},#{birthday},#{address})")
    public int save(User user);

    //@Select("SELECT * FROM user WHERE id = #{id}")
    public User findUserById(int id);
    public List<User> findUserByUserQueryVo(UserQueryVO vo);
    public List<User> findUserByMap(Map<String,Object> map);
}

UserMapper.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.zengqiang.mapper.UserMapper">
   <insert id="save" parameterType="user">
      INSERT INTO user (username,sex,birthday,address)
        VALUE (#{username},#{sex},#{birthday},#{address})
   </insert>
    <select id="findUserById" parameterType="int" resultType="user">
        SELECT * FROM user WHERE id = #{id}
    </select>
    <!--通过包装类查询用户-->
    <select id="findUserByUserQueryVo" parameterType="userQueryVO" resultType="user">
        SELECT u.* FROM user u WHERE u.id = #{user.id}
    </select>
    <!--通过Map查询数据-->
    <select id="findUserByMap" parameterType="hashmap" resultType="user">
        SELECT u.* FROM user u WHERE username LIKE '%${username}%' AND sex = #{sex}
    </select>
</mapper>

> 说明：此时之所以parameterType和resultType等都可以直接简写，是因为在SqlMapConfig.xml种配置了别名
<!--配置别名-->
    <typeAliases>
        <!--方式一-->
        <!--<typeAlias type="com.zengqiang.model.User" alias="user"></typeAlias>-->

        <!--方式二-->
        <!--指定包名，别名就是类名并且第一个字母小写  例如 User 别名就是user-->
        <package name="com.zengqiang.model"></package>
        <package name="com.zengqiang.vo"></package>
    </typeAliases>

基本测试

public class Demo {
    SqlSession session;
    @Before
    public void before() throws IOException {
        System.out.println("before.....获取session");
//        a)读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
        session = sessionFactory.openSession();
    }
    @After
    public void after(){
        session.close();
    }
    @Test
    public void test1() throws IOException {
        //返回的是代理对象，所以可以转换成对应的Mapper
        UserMapper userMapper =  session.getMapper(UserMapper.class);
        //获取数据
        System.out.println(userMapper.findUserById(1));
        //保存
        /*User user2 = new User("xxx","x",new Date(),"xx");
        userMapper.save(user2);
        session.commit();*/
    }
}

包装类和Map查询

public class Demo05 {
    SqlSession session;
    @Before
    public void before() throws IOException {
        System.out.println("before.....获取session");
//        a)读取配置文件；
        InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
        session = sessionFactory.openSession();
    }

    @After
    public void after(){
        session.close();
    }

    @Test
    public void test1() throws IOException {
        UserMapper userMapper =  session.getMapper(UserMapper.class);
        //System.out.println(obj.getClass());
        //通过模型的包装类来查询用户
        UserQueryVO query = new UserQueryVO();
        User user = new User();
        user.setId(1);
        query.setUser(user);
        Order order = new Order();
        order.setNumber("100111");
        query.setOrder(order);
        List<User> list = userMapper.findUserByUserQueryVo(query);
        System.out.println(list);
    }
    @Test
    public void test2() throws IOException {
        UserMapper userMapper =  session.getMapper(UserMapper.class);
        //查询条件
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("username","张");
        map.put("sex","2");
        List<User> list = userMapper.findUserByMap(map);
        System.out.println(list);
    }
}

包装类:
public class UserQueryVO {
    private User user;
    private Order order;
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    public Order getOrder() {
        return order;
    }
    public void setOrder(Order order) {
        this.order = order;
    }
}

输出映射 resultType/resultMap

resultType

使用resultType进行结果映射时，查询的列名和映射的pojo属性名完全一致，该列才能映射成功。
如果查询的列名和映射的pojo属性名全部不一致，则不会创建pojo对象。
如果查询的列名和映射的pojo属性名有一个一致，就会创建pojo对象。

输出单个pojo对象和pojo列表时，mapper映射文件中的resultType的类型是一样的，mapper接口的方法返回值不同。
同样的mapper映射文件，返回单个对象和对象列表时，mapper接口在生成动态代理的时候，会根据返回值的类型，决定调用selectOne方法还是selectList方法。

resultMap

如果查询出来的列名和属性名不一致，通过定义一个resultMap将列名和pojo属性名之间作一个映射关系。

定义resultMap
使用resultMap作为statement的输出映射类型

if和where

If标签：作为判断入参来使用的，如果符合条件，则把if标签体内的SQL拼接上。
注意：用if进行判断是否为空时，不仅要判断null，也要判断空字符串‘’；
Where标签：会去掉条件中的第一个and符号。

foreach遍历

例如：SELECT * FROM user where id in (31,32,33);

SQL片断

Mybatis提供了SQL片段的功能，可以提高SQL的可重用性

SQL片段.png

<?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.zengqiang.mapper.UserMapper">


    <!--1 设置返回数据为基本类型,int,double,long,string....-->
    <!-- 查询用户的个数 -->
    <select id="findUserCount" parameterType="userQueryVO" resultType="int">
        SELECT COUNT(*) FROM  user WHERE sex = #{user.sex}
    </select>

    <!--2.设置返回数据为resultMap -->
    <resultMap id="userResultMap" type="user">
        <id property="id" column="id_"></id>
        <result property="username" column="username_"></result>
        <result property="sex" column="sex_"></result>
        <result property="birthday" column="birthday_"></result>
        <result property="address" column="address_"></result>
    </resultMap>
    <select id="findUserByIdResultMap" parameterType="int" resultMap="userResultMap">
        SELECT
         id id_,
         username username_,
         sex sex_,
         birthday birthday_,
         address address_
        FROM user WHERE id = #{id}
    </select>


    <!-- 3.if和where的使用-->

    <!--声明sql片段，提高重用性-->
    <sql id="select_user_where">
        <if test="user != null">
            <if test="user.sex != null and user.sex != ''">
                sex = #{user.sex}
            </if>
            <if test="user.username != null and user.username != ''">
                and username LIKE '%${user.username}%'
            </if>
            <if test="user.address != null and user.address != ''">
                and address LIKE '%${user.address}%'
            </if>
        </if>
    </sql>
    <select id="findUserList" parameterType="userQueryVO" resultType="user">
        /*性别和名字*/
        SELECT * FROM user

        <where>
--             引用sql片段
            <include refid="select_user_where"/>
        </where>
    </select>
    <!-- 4.foreach使用讲解-->
    <select id="findUserByIds" parameterType="userQueryVO" resultType="user">
        <!--性别和名字 SELECT * FROM user WHERE id in (1,2,3) -->
       SELECT * FROM user
       <where>
           <if test="ids != null and ids.size > 0">
               <!--
               collection:集合,写集合属性
               item:遍历接收变量
               open:遍历开始
               close：遍历结束
               separator:拼接格式
               for(Integer id : ids){
               }
               -->
                <foreach collection="ids" item="id" open="id in(" close=")" separator=",">
                    ${id}
                </foreach>
            </if>
        </where>
    </select>
    <!-- 5.参数是数组(其实就是List)
        如果参数是数组的话，parameterType可以写全名【java.util.List】，也可以写别名,

        另外注意：
        遍历或者判断的时候，都用list变量
    -->
    <select id="findUserByIds2" parameterType="list" resultType="user">
        <!--性别和名字 SELECT * FROM user WHERE id in (1,2,3) -->
        SELECT * FROM user
        <where>
            <if test="list != null and list.size > 0">
                <foreach collection="list" item="id" open="id in(" close=")" separator=",">
                    ${id}
                </foreach>
            </if>
        </where>
    </select>
</mapper>

UserMapper.java

public interface UserMapper {

    /**
     * 返回用户的个数
     * @param vo
     * @return
     */
    public int findUserCount(UserQueryVO vo);
    public User findUserByIdResultMap(int userId);
    /**
     * 讲解mybatis的if和where使用
     * @return
     */
    public List<User> findUserList(UserQueryVO vo);
    /*查找多个id的用户数据*/
    public List<User> findUserByIds(UserQueryVO vo);
    public List<User> findUserByIds2(List<Integer> ids);
    /**
     * 查询用户信息及用户购买的商品信息
     */
    public List<User> findUserAndOrderInfo();
    public User findUserAndOrderInfo(int userId);

}

包装类:pojo
public class UserQueryVO {

    private User user;

    private List<Integer> ids;

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

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

    private Orders order;
    public User getUser() {
        return user;
    }

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

    public Orders getOrder() {
        return order;
    }

    public void setOrder(Orders order) {
        this.order = order;
    }
}

MyBatis泛览一(基本配置和查询)

MyBatis

parameterType和resultType

#{}和${}

{}：相当于预处理中的占位符？。

{}里面的参数表示接收java输入参数的名称。

{}可以接受HashMap、POJO类型的参数。

{}可以防止SQL注入。

selectOne和selectList

Mybatis基本步骤

简化案例(不分层，只使用)

分Dao层(手写实现类，不常用)

Spring自动生成实现类(常用)

步骤

基本测试

包装类和Map查询

输出映射 resultType/resultMap

resultType

resultMap

if和where

foreach遍历

SQL片断

猜你喜欢

热点阅读