澳门网络娱乐游戏平台-澳门电子游戏娱乐网址-官方直营

澳门在线平台:Mybatis学习笔记之后生可畏(情状搭建和入门案例介绍)

1.JDBC编制程序有哪些白璧微瑕,MyBatis是哪些消除这一个难点的?

① 数据库链接创制、释放频仍形成系统能源浪费进而影响系统品质,借使运用数据库链接池可解决此主题材料。

斩尽杀绝:在SqlMapConfig.xml中配置数据链接池,使用连接池管理数据库链接。

② Sql语句写在代码中程导弹致代码不易维护,实际应用sql变化的只怕一点都不小,sql变动必要转移java代码。

消除:将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

③ 向sql语句传参数麻烦,因为sql语句的where条件不自然,恐怕多也或许少,占位符须求和参数风流罗曼蒂克生机勃勃对应。

解决: Mybatis自动将java对象映射至sql语句。

④ 对结果集拆解剖判麻烦,sql变化招致深入分析代码变化,且深入解析前供给遍历,假使能将数据库记录封装成pojo对象解析相比方便。

消灭净尽:Mybatis自动将sql实行结果映射至java对象。

一、Mybatis概述

一、MyBatis 介绍

MyBatis is a first class persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis eliminates almost all of the JDBC code and manual setting of parameters and retrieval of results. MyBatis can use simple XML or Annotations for configuration and map primitives, Map interfaces and Java POJOs to database records.

MyBatis 是一款能够的漫长层框架,它辅助定制化 SQL、存款和储蓄过程以致高级映射。MyBatis 幸免了大约具备的 JDBC 代码和手动设置参数以至获得结果集。MyBatis 能够应用简易的 XML 或评释来配置和照耀原生音信,将接口和 Java 的 POJOs映射成数据库中的记录。

2.MyBatis编制程序手续是何许的?

① 创建SqlSessionFactory
② 通过SqlSessionFactory创建SqlSession
③ 通过sqlsession执行数据库操作
④ 调用session.commit(卡塔尔提交业务
⑤ 调用session.close(卡塔尔(英语:State of Qatar)关闭对话

1.1 Mybatis介绍

二、MyBatis 入门

  1. jdbc程序
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 通过驱动管理类获取数据库链接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");
            // 定义sql语句 ?表示占位符
            String sql = "select * from user where username = ?";
            // 获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数,第一个参数为sql语句中参数的序号(从1开始),第二个参数为设置的参数值
            preparedStatement.setString(1, "张小明");
            // 向数据库发出sql执行查询,查询出结果集
            resultSet = preparedStatement.executeQuery();
            // 遍历查询结果集
            while (resultSet.next()) {
                System.out.println(resultSet.getString("id") + "  " + resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
  1. 使用jdbc操作数据仓库储存在的难题
    1 . 数据库连接创制、释放频仍变成系统能源浪费,进而影响系统质量。借使选取数据库连接池可消除此主题素材。
    2 . Sql语句在代码中硬编码,产生代码不易维护,实际选用中sql变化的或者超级大,sql变动必要改造java代码。
    3 . 利用preparedStatement向据有位符号传参数存在硬编码,因为sql语句的where条件不自然,恐怕多也大概少,改正sql还要改正代码,系统科学维护。
    4 . 对结果集分析存在硬编码,sql变化形成拆解深入分析代码变化,系统科学维护,假使能将数据库记录封装成POJO对象分析相比低价。

  2. MyBatis的入门程序

    澳门在线平台 1

    image.png

log4j.properties
log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

SqlMapConfig.xml mybatis大旨配置文件

<?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>
    <!-- 和spring整合后 environments配置将废除    -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    <!-- 加载映射文件 -->
    <mappers>
        <mapper resource="sqlmap/User.xml"/>
    </mappers>
</configuration>

User.java

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;
    get/set ...
}

User.xml sql映射文件

<?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:命名空间-->
<mapper namespace="test">
    <!-- id:statement的id 或者叫做sql的id-->
    <!-- parameterType:指定输入参数类型 -->
    <!-- resultType:指定输出结果类型,应该填写pojo的全路径 -->
    <!-- #{}:输入参数的占位符,相当于jdbc的? -->
    <select id="findUserById" parameterType="int"
        resultType="com.study.mybatis.pojo.User">
        SELECT * FROM `user` WHERE id  = #{id}
    </select>
    <!-- //根据用户名称模糊查询用户列表
    #{}表示一个占位符号    select * from user where id = ?     ? ==  '五'
    ${}表示拼接sql串    select * from user where username like '%五%'  -->
    <select id="findUserByUsername" parameterType="String" resultType="com.study.mybatis.pojo.User">
        select * from user where username like "%"#{haha}"%"
    </select>
    <!-- 添加用户 -->
    <insert id="insertUser" parameterType="com.study.mybatis.pojo.User">
        <!-- selectKey 标签实现主键返回 -->
        <!-- keyColumn:主键对应的表中的哪一列 -->
        <!-- keyProperty:主键对应的pojo中的哪一个属性 -->
        <!-- order:设置在执行insert语句前执行查询id的sql,还是在执行insert语句之后执行查询id的sql -->
        <!-- resultType:设置返回的id的类型 -->
        <selectKey keyColumn="id" keyProperty="id" resultType="Integer" order="AFTER">
            <!-- mysql的函数,返回auto_increment自增列新记录id值 -->
            select LAST_INSERT_ID()
        </selectKey>
        insert into user (username,birthday,address,sex) 
        values (#{username},#{birthday},#{address},#{sex})
    </insert>
    <!-- 更新 -->
    <update id="updateUserById" parameterType="com.study.mybatis.pojo.User">
        update user 
        set username = #{username},sex = #{sex},birthday = #{birthday},address = #{address}
        where id = #{id}
    </update>
    <!-- 删除 -->
    <delete id="deleteUserById" parameterType="Integer">
        delete from user 
        where id = #{vvvvv}
    </delete>
</mapper>

测量检验程序

public class Test {

    @Test
    public void testMybatis() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行Sql语句 
        User user = sqlSession.selectOne("test.findUserById", 10);
        System.out.println(user);
    }

    //根据用户名称模糊查询用户列表
    @Test
    public void testfindUserByUsername() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行Sql语句 
        List<User> users = sqlSession.selectList("test.findUserByUsername", "五");
        for (User user2 : users) {
            System.out.println(user2);
        }
    }

    //添加用户
    @Test
    public void testInsertUser() throws Exception {
        //加载核心配置文件
        String resource = "sqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行Sql语句 
        User user = new User();
        user.setUsername("鱼虾");
        user.setBirthday(new Date());
        user.setAddress("地址");
        user.setSex("男");
        int i = sqlSession.insert("test.insertUser", user);
        sqlSession.commit();
        System.out.println(user.getId());
    }

    //更新用户
    @Test
    public void testUpdateUserById() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行Sql语句 
        User user = new User();
        user.setId(27);
        user.setUsername("武侠");
        user.setBirthday(new Date());
        user.setAddress("地址2");
        user.setSex("女");
        int i = sqlSession.update("test.updateUserById", user);
        sqlSession.commit();
    }

    //删除
    @Test
    public void testDelete() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        sqlSession.delete("test.deleteUserById", 27);
        sqlSession.commit();
    }

}
  1. MyBatis 化解jdbc编制程序的主题素材
    1 .数据库连接创制、释放频仍变成系统财富浪费进而影响系统品质,如果利用数据库连接池可化解此主题素材。
    缓解:在SqlMapConfig.xml中布置数据连接池,使用连接池管理数据库链接。
    2 .Sql语句写在代码中程导弹致代码不易维护,实际行使sql变化的或是十分大,sql变动须要改动java代码。
    养虎遗患:将Sql语句配置在XXXXmapper.xml文件中与java代码分离。
    3 .向sql语句传参数麻烦,因为sql语句的where条件不肯定,大概多也说不佳少,占位符必要和参数生龙活虎少年老成对应。
    缓慢解决:Mybatis自动将java对象映射至sql语句,通过statement中的parameterType定义输入参数的项目。
    4 .对结果集拆解剖判麻烦,sql变化导致剖析代码变化,且深入分析前供给遍历,固然能将数据库记录封装成pojo对象剖析比较平价。
    养虎遗患:Mybatis自动将sql实行结果映射至java对象,通过statement中的resultType定义输出结果的花色。

  2. MyBatis 与 Hibernate不同
    其风流倜傥标题得深透商讨 一时半刻不打听

3.MyBatis与Hibernate有啥样区别?

    Mybatis和hibernate分歧,它不完全部是贰个ORM框架,因为MyBatis需求程序员本人编写Sql语句,不过mybatis能够通过XML或评释格局灵活配置要运营的sql语句,并将java对象和sql语句映射生成最后实践的sql,最终将sql实行的结果再映射生成java对象。
 
    Mybatis学习秘籍低,轻巧命理术数,程序猿直接编写原生态sql,可严控sql试行性能,灵活度高,非常契合对关全面据模型必要不高的软件开垦,举个例子互连网软件、集团运营类软件等,因为那类软件要求调换频仍,黄金时代但必要变动须要成果输出火速。但是灵活的前提是mybatis不恐怕做到数据库无关性,假若须求达成帮忙三种数据库的软件则须求自定义多套sql映射文件,专门的学问量大。
 
    Hibernate对象/关系映射技术强,数据库非亲非故性好,对于涉嫌模型供给高的软件(譬喻要求牢固的定制化软件)假若用hibernate开辟能够节约数不完代码,进步功用。可是Hibernate的劣势是上学秘技高,要精晓门槛越来越高,並且怎么设计O/逍客映射,在品质和对象模型之间什么权衡,以至哪些用好Hibernate需求有所很强的涉世和力量才行。
总的说来,依据客商的急需在少数的能源蒙受下假设能做出维护性、扩展性优越的软件构造都以好布局,所以框架唯有符合才是最佳。

  MyBatis 本是apache的三个开源项目iBatis, 二零零六年那么些类型由apache software foundation 迁移到了google code,並且改名叫MyBatis 。二零一二年一月搬迁到Github。

三、Dao的开辟方法

行使MyBatis开拓Dao,平常常有多少个办法,即原始Dao开采方法和Mapper动态代理开垦方法。

  1. 原始Dao的开采方法
    原始Dao开拓方法须要程序员编写Dao接口和Dao完毕类。
    在入门程序底子上支出:
    Dao接口
public interface UserDao {
    public User selectUserById(Integer id);
}

Dao实现类

public class UserDaoImpl implements UserDao {

    private SqlSessionFactory sqlSessionFactory;
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    public User selectUserById(Integer id){
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = sqlSession.selectOne("test.findUserById", id);
        sqlSession.close();
        return user;
    }
}

Dao测试

public class TestDao {
    public SqlSessionFactory sqlSessionFactory;

    @Before
    public void before() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    }

    @Test
    public void testSelectById() throws Exception {
        UserDao userDao = new UserDaoImpl(sqlSessionFactory);
        User user = userDao.selectUserById(26);
        System.out.println(user);
    }
}

原始Dao开垦中存在以下难点

  • Dao方法体存在重新代码:通过SqlSessionFactory创设SqlSession,调用SqlSession的数据库操作方法
  • 调用SqlSession的数据库操作方法要求钦赐Statement的id,这里存在硬编码,不得于付出爱慕。
  1. 接口的动态代理形式
    Mybatis官方推荐使用Mapper代理方法开辟Mapper接口
    Mapper接口开辟方法只需求程序猿编写Mapper接口(相当于Dao接口),由Mybatis框架依据接口定义创设接口的动态代理对象,代理对象的艺术体同上面Dao接口完结类格局。
    Mapper接口开采须要根据以下规范:
    1、Mapper.xml文件中的namespace与mapper接口的类路线相符。
    2、Mapper接口方法名和Mapper.xml中定义的各样statement的id相同
    3、Mapper接口方法的输入参数类型和Mapper.xml中定义的每一个sql 的ParameterType的类别雷同
    4、Mapper接口方法的出口参数类型和Mapper.xml中定义的各样sql的ResultType的项目相符

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">
<!-- namespace:命名空间-->
<mapper namespace="com.study.mybatis.mapper.UserMapper">
    <!-- id:statement的id 或者叫做sql的id-->
    <!-- parameterType:声明输入参数的类型 -->
    <!-- resultType:声明输出结果的类型,应该填写pojo的全路径 -->
    <!-- #{}:输入参数的占位符,相当于jdbc的? -->
    <select id="findUserById" parameterType="int"
        resultType="com.study.mybatis.pojo.User">
        SELECT * FROM `user` WHERE id  = #{id}
    </select>

    <!-- //根据用户名称模糊查询用户列表
    #{}    select * from user where id = ?    占位符  ? ==  '五'
    ${}    select * from user where username like '%五%'  字符串拼接  -->
    <select id="findUserByUsername" parameterType="String" resultType="com.study.mybatis.pojo.User">
        select * from user where username like "%"#{haha}"%"
    </select>

    <!-- 添加用户 -->
    <insert id="insertUser" parameterType="com.study.mybatis.pojo.User">
        <selectKey keyProperty="id" resultType="Integer" order="AFTER">
            select LAST_INSERT_ID()
        </selectKey>
        insert into user (username,birthday,address,sex) 
        values (#{username},#{birthday},#{address},#{sex})
    </insert>

    <!-- 更新 -->
    <update id="updateUserById" parameterType="com.study.mybatis.pojo.User">
        update user 
        set username = #{username},sex = #{sex},birthday = #{birthday},address = #{address}
        where id = #{id}
    </update>

    <!-- 删除 -->
    <delete id="deleteUserById" parameterType="Integer">
        delete from user 
        where id = #{vvvvv}
    </delete>

</mapper>

UserMapper 接口文件

public interface UserMapper {
    public User findUserById(Integer id);   
}

加载UserMapper.xml文件
SqlMapConfig.xml

    <!-- 加载映射文件 Mapper的位置 -->
    <mappers>
        <!-- 注意是扫描包 -->
        <package name="com.study.mybatis.mapper" />
    </mappers>

测试

public class TestMapper {

    @Test
    public void testMapper() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //SqlSEssion帮我生成一个实现类  (给接口)
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.findUserById(10);
        System.out.println(user);
    }

}

4.应用MyBatis的mapper接口调用时有哪些必要?

①  Mapper接口方法名和mapper.xml中定义的各个sql的id相似
②  Mapper接口方法的输入参数类型和mapper.xml中定义的每种sql 的parameterType的种类相像
③  Mapper接口方法的输出参数类型和mapper.xml中定义的各类sql的resultType的项目雷同
④  Mapper.xml文件中的namespace就是mapper接口的类路线。

  MyBatis是二个美好的长久层框架,它对jdbc的操作数据库的进程进展打包,使开拓者只供给关爱 SQL 自己,而无需开支精力去管理举个例子登记驱动、成立connection、成立statement、手动设置参数、结果集检索等jdbc繁缛的长河代码。

四、SqlMapConfig.xml文件申明

  1. SqlMapConfig.xml中结构的内容和顺序
    properties(属性)
    settings(全局配置参数)
    typeAliases(类型小名)
    typeHandlers(类型微处理器)
    objectFactory(对象工厂)
    plugins(插件)
    environments(境况集结属性对象)
    environment(情状子属性对象)
    transactionManager(事务管理)
    dataSource(数据源)
    mappers(映射器)
  2. properties
    db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

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>

    <!-- 是用resource属性加载外部配置文件 -->
    <properties resource="db.properties">
        <!-- 在properties内部用property定义属性 -->
        <!-- 如果外部配置文件有该属性,则内部定义属性被外部属性覆盖 -->
        <property name="jdbc.username" value="root123" />
        <property name="jdbc.password" value="root123" />
    </properties>

    <!-- 和spring整合后 environments配置将废除    -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}" />
                <property name="url" value="${jdbc.url}" />
                <property name="username" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />
            </dataSource>
        </environment>
    </environments>
    <!-- 加载映射文件 Mapper的位置 -->
    <mappers>
        <package name="com.study.mybatis.mapper" />
    </mappers>

</configuration>
  1. typeAliases
    <typeAliases>
        <!-- 单个别名定义 -->
        <typeAlias alias="user" type="com.study.mybatis.pojo.User" />
        <!-- 批量别名定义,扫描整个包下的类,别名为类名(大小写不敏感) -->
        <package name="com.study.mybatis.pojo" />
    </typeAliases>

在mapper.xml配置文件中,就能够运用安装的别称了
别称大小写不灵动

  1. mappers
    <mappers>
        <!-- 使用相对于类路径的资源 -->
        <mapper resource="sqlmap/User.xml" />
        <!-- 使用mapper接口类路径 -->
        <!-- 此种方法要求mapper接口名称和mapper映射文件名称相同,且放在同一个目录中 -->
        <mapper class="com.study.mybatis.mapper.UserMapper"/>
        <!-- 注册指定包下的所有mapper接口 -->
        <!-- 此种方法要求mapper接口名称和mapper映射文件名称相同,且放在同一个目录中。 -->
        <package name="com.study.mybatis.mapper"/>
    </mappers>

5.SqlMapConfig.xml中配备有哪些内容?

SqlMapConfig.xml中计划的从头到尾的经过和各样如下: 

style="font-family: Consolas;"> style="font-size: 11pt;">properties(属性)

style="font-family: Consolas;"> style="font-size: 11pt;">settings(配置)

style="font-family: Consolas;"> style="font-size: 11pt;">typeAliases(类型别称)

style="font-family: Consolas;"> style="font-size: 11pt;">typeHandlers(类型微电脑)

style="font-family: Consolas;"> style="font-size: 11pt;">objectFactory(对象工厂)

style="font-family: Consolas;"> style="font-size: 11pt;">plugins(插件)

style="font-family: Consolas;"> style="font-size: 11pt;">environments(情状集结属性对象)

style="font-family: Consolas;"> style="font-size: 11pt;">environment(景况子属性对象)

style="font-family: Consolas;"> style="font-size: 11pt;">transactionManager(事务管理)

style="font-family: Consolas;"> style="font-size: 11pt;">dataSource(数据源)

style="data-wiz-span: 'data-wiz-span';"> style="font-size: 11pt;">mappers style="size: +0;"> style="font-size: 11pt;">(映射器)

  Mybatis通过xml或申明的艺术将在推行的各个statement(statement、preparedStatemnt、CallableStatement)配置起来,并由此java对象和statement中的sql进行映射生成最终实践的sql语句,最后由mybatis框架推行sql并将结果映射成java对象并赶回。

五、输入映射和输出映射

  1. 输入参数映射
    parameterType
  • 传递轻易类型
  • 传递POJO对象
  • 传递POJO包装对象
    <!-- 根据用户名模糊查询 -->
    <select id="findUserByQueryVo" parameterType="QueryVo" resultType="User">
        select * from user where username like "%"#{user.username}"%"
    </select>

public interface UserMapper {

    public User findUserById(Integer id);

    public List<User> findUserByQueryVo(QueryVo vo);

}

测试:

    @Test
    public void testMapperQueryVo() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //SqlSEssion帮我生成一个实现类  (给接口)
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("五");
        vo.setUser(user);
        List<User> userList = userMapper.findUserByQueryVo(vo);
        for (User u : userList) {
            System.out.println(u);
        }
    }
  1. 回到值映射
  • 出口轻易类型
    sql:select count(*) from user
     <select id="countUser" resultType="Integer">
        select count(1) from user
     </select>

    public Integer countUser();

    @Test
    public void testCountUser() throws Exception {
        //加载核心配置文件
        String resource = "sqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        Integer i = userMapper.countUser();
        System.out.println(i);
    }
  • 输出POJO对象

  • 输出POJO列表

  • ResultMap
    ResultType可以钦命将查询结果映射为POJO,但需求POJO的属性名和sql查询的列名一致方可映射成功。
    假诺sql查询字段名和POJO的质量名不风流倜傥致,能够由此ResultMap将字段名和性质名作二个相应关系 ,ResultMap实质上还索要将查询结果映射到POJO对象中。
    ResultMap能够完结将查询结果映射为复杂性类型的POJO,比如在询问结果映射对象中蕴涵POJO和list完结生机勃勃对生机勃勃查询和后生可畏对多询问。

public class Order implements Serializable{

    private static final long serialVersionUID = 1L;

    private Integer id;
    private Integer userId;
    private String number;
    private Date createtime;
    private String note;
    private User user;

    get/set ...
}

<?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.study.mybatis.mapper.OrderMapper">

    <!-- 解决sql查询列(user_id)和Order类属性(userId)不一致的问题 -->
    <resultMap type="Order" id="order">
        <result column="user_id" property="userId"/>
    </resultMap>

    <select id="selectOrderList" resultMap="order">
        SELECT id, user_id, number, createtime, note from orders
    </select>

</mapper>

public interface OrderMapper {

    List<Order> selectOrderList();

}

    @Test
    public void testOrderList() throws Exception {
        //加载核心配置文件
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
        List<Order> ordersList = mapper.selectOrderList();
        for (Order order : ordersList) {
            System.out.println(order);
        }
    }

6.简洁明了的说一下MyBatis的一流缓存和二级缓存?

Mybatis首先去缓存中询问结果集,若无则查询数据库,借使有则从缓存抽出重回结果集就不走数据库。Mybatis内部存款和储蓄缓存使用一个HashMap,key为hashCode+sqlId+Sql语句。value为从询问出来映射生成的java对象

Mybatis的二级缓存即查询缓存,它的功用域是三个mapper的namespace,即在同贰个namespace中查询sql能够从缓存中获取数据。二级缓存是足以跨SqlSession的。

1.2 JDBC操作数据库

六、动态sql

  1. If标签
  2. Where标签
  3. Sql片段
    <!-- Sql片段 -->
    <sql id="selector">
        select * from user
    </sql>

     <select id="selectUserBySexAndUsername" parameterType="User" resultType="User">
        <!-- 如果要使用别的Mapper.xml配置的sql片段,可以在refid前面加上对应的Mapper.xml的namespace -->
        <include refid="selector"/>
        <!-- 如果不加<where>, 需要加上Where 1=1 -->
        <where>
            <if test="sex != null and sex != ''">
                 and sex = #{sex} 
            </if>
            <if test="username != null and username != ''">
                 and username = #{username}
            </if>
        </where>
     </select>

    public List<User> selectUserBySexAndUsername(User user);

    @Test
    public void testfindUserBySexAndUsername() throws Exception {
        //加载核心配置文件
        String resource = "sqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setSex("1");
        user.setUsername("张小明");
        List<User> users = userMapper.selectUserBySexAndUsername(user);
        for (User user2 : users) {
            System.out.println(user2);
        }
    }
  1. foreach标签
    向sql传递数组或List,mybatis使用foreach深入分析,如:select * from user where id in(1,10,24)
public class QueryVo implements Serializable{
    private static final long serialVersionUID = 1L;
    private User user;
    List<Integer> idsList;
    Integer[] ids;

    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    public List<Integer> getIdsList() {
        return idsList;
    }
    public void setIdsList(List<Integer> idsList) {
        this.idsList = idsList;
    }
    public Integer[] getIds() {
        return ids;
    }
    public void setIds(Integer[] ids) {
        this.ids = ids;
    }
}

     <select id="selectUserByIds" parameterType="QueryVo" resultType="User">
        <include refid="selector"/>
        <where>
            <foreach collection="list" item="id" separator="," open="id in (" close=")">
                #{id}
            </foreach>
        </where>
     </select>

三选一
//  public List<User> selectUserByIds(Integer[] ids); // parameterType="Integer" collection="array"
//  public List<User> selectUserByIds(List<Integer> ids); // parameterType="Integer" collection="list"
//  public List<User> selectUserByIds(QueryVo vo); // parameterType="QueryVo" collection="idsList"

    @Test
    public void testfindUserIDs() throws Exception {
        //加载核心配置文件
        String resource = "sqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //创建SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<Integer> idsList  = new ArrayList<>();
        idsList.add(16);
        idsList.add(22);
        idsList.add(24);
        Integer[] idsInteger = new Integer[3];
        idsInteger[0] = 16;
        idsInteger[1] = 22;
        idsInteger[2] = 24;
        QueryVo queryVo = new QueryVo();
        queryVo.setIdsList(idsList);
        List<User> users = userMapper.selectUserByIds(queryVo);
        for (User user2 : users) {
            System.out.println(user2);
        }
    }

7.Mapper编写有哪三种方式?

①接口完结类世袭SqlSessionDaoSupport

接纳此种方法需求编写制定mapper接口,mapper接口完成类、mapper.xml文件

1、在sqlMapConfig.xml中配置mapper.xml的位置

 

  1. <mappers>
  2. <mapper resource="mapper.xml文件的地址" />
  3. <mapper resource="mapper.xml文件的地址" />
  4. </mappers>

 

2、定义mapper接口

3、达成类集成SqlSessionDaoSupport

mapper方法中得以this.getSqlSession(卡塔尔(英语:State of Qatar)举行多少增加和删除改查。

4、spring 配置

 

  1. <bean id=" " class="mapper接口的实现">
  2. <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
  3. </bean>

②使用org.mybatis.spring.mapper.MapperFactoryBean

 

1、在sqlMapConfig.xml中配置mapper.xml的位置

假使mapper.xml和mappre接口的名面生龙活虎致且在同一个目录,这里可以毫不配置

 

  1. <mappers>
  2. <mapper resource="mapper.xml文件的地址" />
  3. <mapper resource="mapper.xml文件的地址" />
  4. </mappers>

 

2、定义mapper接口

注意

1、mapper.xml中的namespace为mapper接口的地点

2、mapper接口中的方法名和mapper.xml中的定义的statement的id保持大器晚成致

3、 Spring中定义

 

  1. <bean id="" class="org.mybatis.spring.mapper.MapperFactoryBean">
  2. <property name="mapperInterface"   value="mapper接口地址" />
  3. <property name="sqlSessionFactory" ref="sqlSessionFactory" />
  4. </bean>

③使用mapper扫描器

 

1、mapper.xml文件编写,

注意:

mapper.xml中的namespace为mapper接口的地点

mapper接口中的方法名和mapper.xml中的定义的statement的id保持生机勃勃致

比方将mapper.xml和mapper接口的称号保持生机勃勃致则不用在sqlMapConfig.xml中开展配备 

2、定义mapper接口

瞩目mapper.xml的文书名和mapper的接口名称保持风流倜傥致,且放在同一个目录

3、配置mapper扫描器

 

  1. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  2. <property name="basePackage" value="mapper接口包地址"></property>
  3. <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
  4. </bean>

4、使用扫描器后从spring容器中赢得mapper的贯彻指标

 

扫描器将接口通过代理方法生成完结目的,要spring容器中活动注册,名字为mapper 接口的称谓。

【JDBC】操作步骤

七、关联合检查询

  1. 黄金时代对豆蔻梢头涉及
    SELECT o.id, o.user_id userId, o.number, o.createtime, o.note, u.username, u.address FROM order o LEFT JOIN user u ON o.user_id = u.id
  • 方法一:使用resultType
public class OrderUser extends Order{
    user的属性
    ...  ...
}
  • 方法二:使用resultMap
public class Order implements Serializable{
    private User user;
    ...
}

    <resultMap type="Order" id="orderUser">
        <result column="id" property="id"/>
        <result column="user_id" property="userId"/>
        <result column="number" property="number"/>
        <!-- 一对一 -->
        <association property="user" javaType="User">
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
        </association>
     </resultMap>
    <select id="selectOrder" resultMap="orderUser">
        SELECT 
        o.id,
        o.user_id, 
        o.number,
        o.createtime,
        u.username 
        FROM orders o 
        left join user u 
        on o.user_id = u.id
     </select>

    public List<Order> selectOrder();

    @Test
    public void testOrderUser() throws Exception {
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
        List<Order> selectOrderList = orderMapper.selectOrder();
        for (Order orders : selectOrderList) {
            System.out.println(orders);
        }
    }
  1. 风流倜傥对多关系
    SELECT u.id, u.username, u.birthday, u.sex, u.address, o.id oid, o.number, o.createtime, o.note FROM user u LEFT JOIN order o ON u.id = o.user_id
public class User implements Serializable{
    private List<Order> ordersList;
    ... ...
}

    <resultMap type="User" id="user">
        <id column="user_id" property="id"/>
        <result column="username" property="username"/>
        <!-- 一对多 -->
        <collection property="ordersList" ofType="Order">
            <id column="id" property="id"/>
            <result column="number" property="number"/>
        </collection>
    </resultMap>
    <select id="selectUserList" resultMap="user">
        SELECT 
        o.id,
        o.user_id, 
        o.number,
        o.createtime,
        u.username 
        FROM user u
        left join orders o 
        on o.user_id = u.id
    </select>

    public List<User> selectUserList();

    @Test
    public void testUserList() throws Exception {
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
        List<User> users = orderMapper.selectUserList();
        for (User user : users) {
            System.out.println(user);
        }
    }

  1、加载数据库驱动

八、MyBatis整合Spring

MyBatis Spring的布置文件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>
    <!-- 设置别名 -->
    <typeAliases>
        <!-- 2. 指定扫描包,会把包内所有的类都设置别名,别名的名称就是类名,大小写不敏感 -->
        <package name="com.study.mybatis.pojo" />
    </typeAliases>

    <mappers>
        <package name="com.study.mybatis.mapper"/>
    </mappers>
</configuration>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <context:property-placeholder location="classpath:db.properties"/>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="10" />
        <property name="maxIdle" value="5" />
    </bean>

    <!-- Mybatis的工厂 -->
    <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 核心配置文件的位置 -->
        <property name="configLocation" value="classpath:sqlMapConfig.xml"/>
    </bean>

    <!-- Mapper动态代理开发   扫描 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 基本包 -->
        <property name="basePackage" value="com.study.mybatis.mapper"/>
    </bean>

</beans>

db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

log4j.properties

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

先选用下边介绍的Mybatis 自动生成代码插件生成Mapper和POJO
测量检验代码:

public class TestMybatis {

    private ApplicationContext context;

    @Before
    public void setUp() throws Exception {
        this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }

    @Test
    public void testInsert() {
        // 获取Mapper
        UserMapper userMapper = this.context.getBean(UserMapper.class);
        User user = new User();
        user.setUsername("鱼虾");
        user.setSex("1");
        user.setBirthday(new Date());
        user.setAddress("上海");
        userMapper.insert(user);
    }

    @Test
    public void testSelectByExample() {
        // 获取Mapper
        UserMapper userMapper = this.context.getBean(UserMapper.class);
        // 创建User对象扩展类,用户设置查询条件
        UserExample example = new UserExample();
        example.createCriteria().andUsernameLike("%张%");
        // 查询数据
        List<User> list = userMapper.selectByExample(example);
        System.out.println(list.size());
    }

    @Test
    public void testSelectByPrimaryKey() {
        // 获取Mapper
        UserMapper userMapper = this.context.getBean(UserMapper.class);
        User user = userMapper.selectByPrimaryKey(1);
        System.out.println(user);
    }

}

TODO 测试UserMapper.xml 自动生成有问题 很奇怪 mybatis逆向工程生成的resultMap的id重复怎么办
mybatis逆向工程改造的resultMap的id重复
周一解决这个问题

  2、成立并获得数据库链接

九、Mybatis 自动生成代码插件

  • ##### mybatis generator github

率先须求在pom.xml文件增加mybatis-generator信任包以致插件

<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.2</version>
</dependency>

在build的plugins中添加:

    <build>
        <plugins>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <configuration>
                      <!-- mybatis用于生成代码的配置文件 -->
                      <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
                <dependencies>
                    <!--此处添加一个mysql-connector-java依赖可以防止找不到jdbc Driver-->
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>6.0.6</version>
                        <scope>runtime</scope>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

配置generatorConfig.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
    PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
    "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <commentGenerator>
            <property name="suppressDate" value="false"/>
            <!-- 是否自动生成的注释 -->
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&amp;nullNamePatternMatchesAll=true"
                        userId="root"
                        password="root">
        </jdbcConnection>

        <!-- 默认false,把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer,为 true时把JDBC DECIMAL 和
            NUMERIC 类型解析为java.math.BigDecimal -->
        <javaTypeResolver >
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator targetPackage="com.study.mybatis.pojo" targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>

        <!-- targetProject:mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="com.study.mybatis.mapper"
                         targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>

        <!-- targetPackage:mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.study.mybatis.mapper"
                             targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>

        <!--<table schema="DB2ADMIN" tableName="ALLTYPES" domainObjectName="Customer" >
            <property name="useActualColumnNames" value="true"/>
            <generatedKey column="ID" sqlStatement="DB2" identity="true" />
            <columnOverride column="DATE_FIELD" property="startDate" />
            <ignoreColumn column="FRED" />
            <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
        </table>-->
        <!-- 指定数据库表 -->
        <table schema="" tableName="user"></table>
        <table schema="" tableName="orders"></table>
    </context>
</generatorConfiguration>

到此甘休,全体的配备已终结。

  • ##### mybatis-generator-plugin github

  3、创建jdbc statement对象

大概境遇的标题

  • Mapper映射文件不设有极其
    在pom文件增添能源配置
<project>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

  4、设置sql语句

资料

MyBatis官方文书档案
MyBatis普通话文书档案

  5、设置sql语句中的参数(使用preparedStatement卡塔尔

  6、通过statement施行sql并赢得结果

  7、对sql推行结果实行剖判管理

  8、释放财富(resultSet、preparedstatement、connection卡塔尔(英语:State of Qatar)

【编写三个JDBC程序】

public static void main(String[] args) {
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;

    try {
        // 加载数据库驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 通过驱动管理类获取数据库链接
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "admin");
        // 定义sql语句 ?表示占位符
        String sql = "select * from user where username = ?";
        // 获取预处理statement
        preparedStatement = connection.prepareStatement(sql);
        // 设置参数,第一个参数为sql语句中参数的序号(从1开始),第二个参数为设置的参数值
        preparedStatement.setString(1, "kevin");
        // 向数据库发出sql执行查询,查询出结果集
        resultSet = preparedStatement.executeQuery();
        // 遍历查询结果集
        while (resultSet.next()) {
            System.out.println(resultSet.getString("id") + "  " + resultSet.getString("username"));
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 释放资源
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

【JDBC难点总括如下】

  ● 数据库连接创设、释放频仍变成系统能源浪费,进而影响系统特性。假如运用数据库连接池可缓慢解决此难点。

  ● Sql语句在代码中硬编码,变成代码不易维护,实际运用中sql变化的可能很大,sql变动供给转移java代码。

  ● 使用preparedStatement向占领位符号传参数存在硬编码,因为sql语句的where条件不自然,只怕多也说不许少,修正sql还要修正代码,系统科学维护。

  ● 对结果集分析存在硬编码(查询列名),sql变化造成剖析代码变化,系统科学维护,要是能将数据库记录封装成pojo对象拆解解析相比便于。

1.3 Mybatis架构

澳门在线平台 2

● mybatis配置

  SqlMapConfig.xml,此文件作为mybatis的大局配置文件,配置了mybatis的运营碰着等音信。

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

● 通过mybatis情况等安排音讯构造SqlSessionFactory即会话工厂

● 由会话工厂创立sqlSession即会话,操作数据库必要通过sqlSession进行。

● mybatis底层自定义了Executor实践器接口操作数据库,Executor接口有多少个达成,一个是着力实践器、一个是缓存推行器。

● Mapped Statement也是mybatis叁个底层封装对象,它包裹了mybatis配置音讯及sql映射消息等。mapper.xml文件中贰个sql对应三个Mapped Statement对象,sql的id就是Mapped statement的id。

● Mapped Statement对sql实行输入参数举办定义,蕴含HashMap、基本类型、pojo,Executor通过Mapped Statement在实行sql前将输入的java对象映射至sql中,输入参数映射就是jdbc编制程序中对preparedStatement设置参数。

● Mapped Statement对sql实践输出结果进行定义,包涵HashMap、基本项目、pojo,Executor通过Mapped Statement在试行sql后将出口结果映射至java对象中,输出结果映射进程相当于jdbc编制程序中对结果的分析管理进程。

 

二、Mybatis入门案例

2.1 Mybatis下载

mybatis的代码由github.com管理,下载网站:

下载落成解压后文件目录如下:

本文由澳门网络娱乐游戏平台发布于编程,转载请注明出处:澳门在线平台:Mybatis学习笔记之后生可畏(情状搭建和入门案例介绍)

相关阅读