一 mybatis入门

r囧r小猫 2022-05-08 12:24 266阅读 0赞

一 mybatis入门  
    1.1 mybatis是什么  
        MyBatis是一个简化和实现了 Java 数据持久化层(persistence layer)  
          
        的开源框架，它抽象了大量的JDBC冗余代码，并提供了一个简单易用的  
          
        API和数据库交互。  
        MyBatis的前身是iBATIS，iBATIS于2002年由ClintonBegin创建  
          
        。MyBatis3是iBATIS的全新设计，支持注解和Mapper。  
        MyBatis流行的主要原因在于它的简单性和易使用性。在Java应用程序中  
          
        ，数据持久化层涉及到的工作有：将从数据库查询到的数据生成所需要的  
          
        Java对象；将Java对象中的数据通SQL持久化到数据库中。  
        MyBatis通过抽象底层的JDBC代码，自动化SQL结果集产生Java对象  
          
        、Java对象的数据持久化数据库中的过程使得对SQL的使用变得容易。

1.2 Git 是一个免费开源的分布式版本控制系统，被用于高速有效地处理大大小小项  
          
    目中所有文件,在软件开发中使用的其他版本控制软件类似与SVN、VSS、CVS等等.

1.3 作为一个分布式的版本控制系统，在Git中并不存在主库这样的概念，每一份复制出的  
          
    库都可以独立使用，任何两个库之间的不一致之处都可以进行合并。github以托管  
          
    各种git库，并提供一个web界面，可以说是一款易于使用的git图形客户端。我们  
          
    熟知的spring、struts、Hibernate等框架的源代码在github上面都可以找到  
          
    其源代码

1.4 iBATIS一词来源于internet和abatis的组合，是一个在2002年发起的开放源代码项目  
          
    。于2010年6月16号被谷歌托管，改名为MyBatis。  
        ibatis的官网 http://ibatis.apache.org/ 进去官网会看到下面提示:  
        apache ibatis is retired at the apache   
        software foundation (2010/06/16)  
        the original project team has moved to   
            mybatis hosted at google code.  
         see http://www.mybatis.org/ for more.  
        然而http://www.mybatis.org/这个地址一直处于打不开状态...  
        但是我们最终是可以在github中找到mybatis的相关下载的:  
        mybatis在github中的地址  
        https://github.com/mybatis/mybatis-3  
        最新版本的mybatis的下载地址  
        https://github.com/mybatis/mybatis-3/releases  
        doc文档  
        http://www.mybatis.org/mybatis-3/  
      
    1.5 当前有很多Java实现的持久化框架，而MyBatis流行起来有以下原因：  
        1.5.1 它消除了大量的JDBC冗余代码  
    Java通过JDBC的API来操作关系型数据库，但是JDBC是一个非常底层的API,我们需要书  
      
    写大量的代码来完成对数据库的操作。例如一个插入操作(参考之前学习JDBC时候的代码实例)  
    但是使用mybatis来完成相同的插入操作要简单方便灵活的多:  
            第一步:在SQLMapper映射配置文件中配置SQL语句，假定为StudentMapper.xml  
            <insert id="insertStudent" parameterType="Student">   
                INSERT INTO STUDENTS(ID,NAME,EMAIL)    
                VALUES(\#\{id\},\#\{name\},\#\{email\})   
            </insert>   
            第二步:创建一个StudentMapper接口  
            public interface StudentMapper\{   
                void insertStudent(Student student);   
            \}   
            第三步:编写java代码完成插入操作:  
            SqlSession session = getSqlSessionFactory().openSession();   
            StudentMapper mapper = session.getMapper(StudentMapper.class);   
            mapper.insertStudent(student);   
              
            特别之处的是，MyBatis还提供了其他的一些特性来简化持久化逻辑的实现  
            它支持复杂的SQL结果集数据映射到嵌套的对象结构  
            它支持一对一和一对多的结果集和Java对象的映射  
            它支持根据输入的数据构建动态的SQL语句  
        1.5.2 它有低的学习曲线  
            MyBatis能够流行的首要原因之一在于它学习和使用起来非常简  
          
            单，它取决于你Java和 SQL方面的知识。如果开发人员很熟悉Java和SQL，  
          
            他们会发现MyBatis入门非常简单。  
          
        1.5.3 它可以接受SQL语句  
            成熟的ORM框架鼓励使用实体对象和在其底层自动产生SQL语句  
          
            。由于这种的SQL生成方式，我们有可能不能够利用到数据库的一些特有的  
          
            特性。Hibernate允许执行本地SQL，但是这样会打破持久层和数据库独立  
          
            的原则。MyBatis框架接受SQL语句，而不是将其对开发人员隐藏起来。  
          
            由于MyBatis不会产生任何的SQL语句，所以开发人员就要准备SQL语句，  
          
            这样就可以充分利用数据库特有的特性并且可以  
          
            准备自定义的查询。另外，MyBatis 对存储过程也提供了支持。  
        1.5.5 它提供了与Spring框架的集成支持  
            MyBatis提供了与流行的依赖注入框架Spring的开包即用的集成  
          
            支持，这将进一步简化MyBatis的使用  
        1.5.6 它提供了与第三方缓存类库的集成支持  
            MyBatis有内建的SqlSession级别的缓存机制，用于缓存Select  
          
            语句查询出来的结果。  
          
            除此之外，MyBatis提供了与多种第三方缓存类库的集成支持，如EHCache，  
          
            OSCache，Hazelcast等。  
        1.5.7 它引入了更好的性能  
        性能问题是关乎软件应用成功与否的关键因素之一。为了达到更好的性能，  
          
        需要考虑很多事情，而对很多应用而言，数据持久化层是整个系统性能的关键。  
          
        MyBatis支持数据库连接池，消除了为每一个请求创建一个数据库连接的  
          
        开销,MyBatis提供了内建的缓存机制，在SqlSession级别提供了对SQL  
          
        查询结果的缓存。即:如果你调用了相同的select查询，MyBatis 会将  
          
        放在缓存的结果返回，而不会去再查询数据库。MyBatis框架并没有大量  
          
        地使用代理机制，因此对于其他的过度地使用代理  
          
        的ORM框架而言，MyBatis可以获得更好的性能.  
      
    1.6 mybatis的jar包  
        mybatis的核心包只有一个mybatis-3.x.0.jar,另外还有一些  
      
        【可选】的依赖包(日志、代理等所需要的),在下载的压缩包中可以找到.  
      
    1.7 mybatis框架中一般需要俩种文件:  
        第一种:mybatis的配置文件: mybatis-config.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>   
              <typeAliases>   
                <typeAlias alias="Student" type="com.briup.pojo.Student" />   
              </typeAliases>   
              <environments default="development">   
                <environment id="development">   
                  <transactionManager type="JDBC" />   
                   <dataSource type="POOLED">  
                      
                    <property name="driver" value="oracle.jdbc.driver.OracleDriver" />   
                    <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:XE" />   
                    <property name="username" value="test" />   
                    <property name="password" value="test" />   
                  </dataSource>   
                </environment>   
              </environments>   
              <mappers>   
                <mapper resource="com/briup/pojo/StudentMapper.xml" />   
              </mappers>   
            </configuration>

第二种:mybatis的映射文件:XxxxxMapper.xml,这个xml文件中  
          
        包括Xxxx类所对应的数据库表的各种增删改查sql语句  
            特点:  
                名字一般为XxxxMapper.xml,Xxxx是对应类的名字  
                位置不固定,一般放到一个专门的package里面  
            实例:  
            <?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.briup.pojo.StudentMapper">   
              <resultMap type="Student" id="StudentResult">   
                <id property="id" column="id" />   
                <result property="name" column="name" />   
                <result property="email" column="email" />   
              </resultMap>   
              <select id="findAllStudents" resultMap="StudentResult">   
                    SELECT \* FROM STUDENTS   
              </select>   
              <select id="findStudentById" parameterType="int" resultType="Student">   
                 SELECT ID AS STUDID, NAME, EMAIL    
                     FROM STUDENTS WHERE ID=\#\{Id\}   
              </select>   
              <insert id="insertStudent" parameterType="Student">   
                 INSERT INTO STUDENTS(ID,NAME,EMAIL)    
                     VALUES(\#\{id \},\#\{name\},\#\{email\})   
              </insert>   
            </mapper>   
      
    1.8 mybatis中的映射接口XxxxMapper.java(对XxxxMapper.xml中的sql语句进行映射)  
        mybatis中除了必须的jar包、各种xml配置文件之外,一般还需要有调用sql语句执  
          
        行的接口XxxxMapper.java  
        示例:  
        public interface StudentMapper\{  
            List<Student> findAllStudents();   
            Student findStudentById(Integer id);   
            void insertStudent(Student student);   
        \}  
        注意:接口中的方法的名字和XML文件定义的SQL映射语句的名称要相同  
        同时我们不需要去实现该接口,因为mybatis中提供了相应的方式在运行期间动  
          
        态生成该接口的实现类对象(动态代理技术,spring框架中会想些讲解动态代理).

1.9 mybatis中的SqlSession接口和sqlSessionFactory接口  
        SqlSession接口的实现类对象是mybatis中最重要的一个对象,我们可以使用该对象  
      
        动态获得XxxxMapper.java接口的实现类对象,然后就可以调用到XxxxMapper.java接口中方法所映射  
      
        的sql语句(在xml文件中配置的sql语句)。  
        sqlSessionFactory接口的实现类对象是一个工厂对象,专门负责来产生SqlSession对象的  
        例如:  
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");   
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
        SqlSession sqlSession = sqlSessionFactory.openSession();  
          
        //第一种执行sql语句的方式  通过XxxxMapper接口的实现类对象来调用  
        //动态获得XxxxMapper接口的实现类  
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);  
        studentMapper.insertStudent(new Student(1,"tom","123@.qq.com"));  
          
        //第二种执行sql语句的方式  执行调用XxxxMapper.xml中写好的sql语句  
        //也可以【不通过】Mapper接口执行映射的SQL  
        //然而，使用 Mapper接口是最佳实践  
        //sqlSession.selectOne("com.briup.pojo.StudentMapper.findStudentById",1);

1.10 编写一个简单的mybatis进行插入数据的实例  
        1.10.1 数据库建表  dob=Date of Birth  
            CREATE TABLE STUDENTS (   
                stud\_id number PRIMARY KEY,   
                name varchar2(50) ,   
                email varchar2(50) ,   
                dob date   
            );   
          
        1.10.2 新建一个项目,创建好相应的package及class  
            package com.briup.pojo;  
            import java.util.Date;  
            public class Student \{  
                private Integer studId;   
                private String name;   
                private String email;   
                private Date dob;  
                get/set  
            \}

1.10.3 项目中引入mybatis的核心包以及可选的依赖包  
            必须的包  mybatis-3.3.0.jar    ojdbc14.jar  
            可选的包  junit-4.7.jar             log4j-1.2.17.jar  
        1.10.4 mybatis中的配置文件和映射文件分别引入到项目中  
            src下面的mybatis-config.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>  
                    <typeAlias type="com.briup.pojo.Student" alias="Student" />  
                </typeAliases>

com.briup.mappers包下面的StudentMapper.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.briup.mappers.StudentMapper">

<select id="findAllStudents" resultMap="StudentResult">  
                    SELECT \* FROM STUDENTS  
                </select>

<select id="findStudentById" parameterType="int" resultType="Student">  
                    SELECT STUD\_ID AS STUDID,NAME,EMAIL,DOB  
                    FROM STUDENTS  
                    WHERE  
                    STUD\_ID=\#\{id\}  
                </select>  
                <insert id="insertStudent" parameterType="Student">   
                    INSERT INTO  
                    STUDENTS(STUD\_ID,NAME,EMAIL,DOB)   
                    VALUES(\#\{studId\},\#\{name\},\#\{email\},\#\{dob\})   
                </insert>  
            </mapper>  
          
        1.10.5 配置log4j.properties文件中的日志输出:  
            位置src下面  
            内容:  
            log4j.rootLogger=DEBUG, stdout   
            log4j.appender.stdout=org.apache.log4j.ConsoleAppender   
            log4j.appender.stdout.layout=org.apache.log4j.PatternLayout   
            log4j.appender.stdout.layout.ConversionPattern=%d \[%-5p\] %c - %m%n  
            \#show sql  
            log4j.logger.java.sql.ResultSet=INFO    
            log4j.logger.org.apache=INFO    
            log4j.logger.java.sql.Connection=DEBUG    
            log4j.logger.java.sql.Statement=DEBUG    
            log4j.logger.java.sql.PreparedStatement=DEBUG

1.10.6 com.briup.mappers包下面新建一个接口StudentMapper.java,用来对应xml文件中  
        的sql语句(映射),从而方便我们调用  
            package com.briup.mappers;  
            import java.util.List;  
            import com.briup.pojo.Student;

//创建映射器Mapper接口StudentMapper  
            //方法名和StudentMapper.xml中定义的SQL映射定义名相同  
            //这个其实就是dao层接口(数据访问层,负责和数据库进行交互)  
            public interface StudentMapper \{  
                List<Student> findAllStudents();   
                Student findStudentById(Integer id);   
                void insertStudent(Student student);  
            \}

1.10.7 创建一个测试类StudentMapperTest.java  
            package test;  
            import java.io.InputStream;  
            import java.util.Date;

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.Test;

import com.briup.mappers.StudentMapper;  
            import com.briup.pojo.Student;

public class StudentMapperTest \{  
                  
                @Test  
                public void testCreateStudent()\{  
                      
                    try \{  
                        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");   
                        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
                        SqlSession sqlSession = sqlSessionFactory.openSession();  
                          
                        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);  
                        Student s = new Student(1,"tom","123@briup.com",new Date());  
                        studentMapper.insertStudent(s);  
                        sqlSession.commit();  
                    \} catch (Exception e) \{  
                        e.printStackTrace();  
                    \}  
                      
                \}  
            \}

1.10.8 运行成功后会在控制台中看到log4j日志输出的这个程序运行的相关信息

1.10.9 对mybatis的一些基本封装  
            每次读取配置文件,产生一个工厂对象SqlSessionFactory,然后再生成  
            出SqlSession对象,这个过程虽然并不复杂,但是也都是一些重复的代码流程,  
            所以我们可以对其进行一个简单的封装:  
            package com.briup.utils;

import java.io.IOException;  
            import java.io.InputStream;

public class MyBatisSqlSessionFactory \{  
                private static SqlSessionFactory sqlSessionFactory;  
                  
                public static SqlSessionFactory getSqlSessionFactory()\{  
                    if(sqlSessionFactory == null)\{  
                        InputStream inputStream = null;  
                        try \{  
                            inputStream = Resources.getResourceAsStream("mybatis-config.xml");   
                            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
                        \} catch (IOException e) \{  
                            e.printStackTrace();  
                            throw new RuntimeException(e.getCause());  
                        \}  
                    \}  
                    return sqlSessionFactory;  
                \}  
                  
                public static SqlSession openSession() \{   
                    return openSession(false);   
                \}  
                public static SqlSession openSession(boolean autoCommit) \{   
                    return getSqlSessionFactory().openSession(autoCommit);   
                \}  
                  
            \}

之后每次使用的时候只需要调用该类中的静态方法openSession即可  
            上面的代码可简写为: //注意事务是自动提交还是手动提交  
            MyBatisSqlSessionFactory.openSession().getMapper(StudentMapper.class).insertStudent(s);