zoukankan      html  css  js  c++  java
  • MyBatis入门学习-连接oracle实现CURD基本操作

    前言

    本篇记录使用mybatis连接oracle数据库实现基本的CURD操作。

    导入oracle库

    由于oracle收费, 因此maven没有oracle库包,需要我们自己导入,可以手工导入外部包,也可以将oracle的jar导入到maven库种。具体导入步骤可以查看Maven添加Oracle的依赖及驱动

    导入mybatis库包,我本地使用的是3.5.5版本。最后的配置如下所示

    
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.5</version>
    </dependency>
    
    <dependency>
      <groupId>com.oracle.jdbc</groupId>
      <artifactId>ojdbc6</artifactId>
      <version>11.2.0.1.0</version>
    </dependency>
    

    配置

    准备mybatis的配置,在resources目录下新建一个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>
        <properties>
            <property name="driver" value="oracle.jdbc.driver.OracleDriver" />
            <property name="url" value="jdbc:oracle:thin:@10.60.45.239:1521:devdb" />
            <property name="username" value="fgmain10001" />
            <property name="password" value="test1" />
        </properties>
    
        <!-- 环境,可以配置多个,default:指定采用哪个环境 -->
        <environments default="test">
            <!-- id:唯一标识 -->
            <environment id="test">
                <!-- 事务管理器,JDBC类型的事务管理器 -->
                <transactionManager type="JDBC" />
                <!-- 数据源,池类型的数据源 -->
                <dataSource type="POOLED">
                    <property name="driver" value="oracle.jdbc.driver.OracleDriver" />
                    <property name="url" value="jdbc:oracle:thin:@10.60.45.239:1521:devdb" />
                    <property name="username" value="fgmain10001" />
                    <property name="password" value="test1" />
                </dataSource>
            </environment>
            <environment id="development">
                <!-- 事务管理器,JDBC类型的事务管理器 -->
                <transactionManager type="JDBC" />
                <!-- 数据源,池类型的数据源 -->
                <dataSource type="POOLED">
                    <property name="driver" value="${driver}" /> <!-- 配置了properties,所以可以直接引用 -->
                    <property name="url" value="${url}" />
                    <property name="username" value="${username}" />
                    <property name="password" value="${password}" />
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <mapper resource="singleTransMapper.xml" />
        </mappers>
    </configuration>
    
    

    环境配置

     <environment id="test">
          <!-- 事务管理器,JDBC类型的事务管理器 -->
          <transactionManager type="JDBC" />
          <!-- 数据源,池类型的数据源 -->
          <dataSource type="POOLED">
              <property name="driver" value="oracle.jdbc.driver.OracleDriver" />
              <property name="url" value="jdbc:oracle:thin:@10.60.45.239:1521:devdb" />
              <property name="username" value="fgmain10001" />
              <property name="password" value="test1" />
          </dataSource>
      </environment>
    

    其中environments可以配置多个环境的oracle数据源。

    id是环境变量的编号,在<environments>default中可以设置当前的环境值。
    dataSource中设置数据源。类型有3种。包括:POOLED池化,UNPOOLED非池化和JNDI从其他配置元加载。
    driver配置的类名,oracle填写oracle.jdbc.driver.OracleDriver
    url为配置的数据源,使用239测试库jdbc:oracle:thin:@10.60.45.239:1521:devdb
    username是用户名。
    password是密码。

    配置引用

    在value中可以填写如${变量名}的配置引用,通过在properties/propertie添加对应的实际的配置值。

    <configuration>
        <properties>
            <property name="driver" value="oracle.jdbc.driver.OracleDriver" />
        </properties>
        
        <environments default="test">
            ...
            <environment id="test">
                ...
                <dataSource type="POOLED">
                    <property name="driver" value="${driver}" /> <!-- 配置了properties,所以可以直接引用 -->
                    ...
                </dataSource>
            </environment>
        </environments>
    </configuration>
    

    配置映射

    配置好数据源后,需要添加对应的表映射,映射包括CRUD对应的SQL语句以及与类之间的映射关系。

    
    <configuration>
      ...
        <mappers>
            <mapper resource="singleTransMapper.xml" />
        </mappers>
    </configuration>
    

    在resources目录下新建一个singleTransMapper.xml文件,MyBatis会将singleTransMapper.xml映射到对应的类

    除了resources以外MyBatis还支持classurlpackage共四种配置

    class可以配置具体类名,如com.mybatistest.DAO.SingleTransMapper
    url可以配置完整的文件路径,如file:///var/mappers/PostMapper.xml
    package可以配置package名称,注册所有接口。

    查询

    
    public class SingletransDTO {
    
        public String EnterpriseNum;
    
        public String TransNo;
    
        public String CommandCode;
    
        public int State;
    }
    
    

    单条件查询

    增加一个查询单笔的语句,通过输入流水号,返回查询到的单笔信息。

    <?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="DAO.SingleTransMapper">
        <select id="selectSingle" parameterType="String" resultType="DTO.SingletransDTO">
        select * from se_singletrans where transno = #{transno}
      </select>
    </mapper>
    
    

    namespace需要对应到java中的类,参数和返回类型也需要一致。

    在mapper节点下添加select表示select语句
    parameterType为输入的参数
    resultType为返回的类型,返回类型需要对应java中的类

    
    public interface SingleTransMapper {
        SingletransDTO selectSingle(String transNo);
    }
    
    
    
    String resource = "mybatis-config.xml";
    //加载资源
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //创建session
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    try (SqlSession session = sqlSessionFactory.openSession()) {
      //获取单笔映射对象
        SingleTransMapper mapper = session.getMapper(SingleTransMapper.class);
        //根据流水号查询
        SingletransDTO blog = mapper.selectSingle("642EHDCS899XKF8P");
    
        if(blog != null) {
            System.out.println(blog.ENTERPRISENUM);
            System.out.println(blog.TRANSNO);
            System.out.println(blog.COMMANDCODE);
        }else{
            System.out.println("not found");
        }
    
    }catch (Exception exception)
    {
        System.out.println(exception.getMessage());
    }
    

    多条件查询

    通过类字段传递参数

    添加一个查询配置selectSingleByParam

    <?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="DAO.SingleTransMapper">
       
       ...
        <select id="selectSingleByClass" resultType="DTO.SingletransDTO">
        select * from se_singletrans where transno = #{TransNo} and commandCode= #{CommandCode}
      </select>
    </mapper>
    

    对应的映射类添加方法对应的方法,MyBatis可以通过反射将类的字段映射到SQL的参数,需要注意的是类的字段名和sql中配置的大小写需要一致。

    
    public interface SingleTransMapper {
      ...
      SingletransDTO selectSingleByClass(SingleCondition singleCondition);
    }
    public class SingleCondition {
        /**
         * 流水号
         */
        public String TransNo;
    
        /**
         * 指令类型
         */
        public String CommandCode;
    
        public SingleCondition(String transNo, String commandCode)
        {
            TransNo = transNo;
            CommandCode = commandCode;
        }
    }
    
    

    调用构造函数类的多条件查询方案

    ...
    SingleTransMapper mapper = session.getMapper(SingleTransMapper.class);
    SingletransDTO blog = mapper.selectSingleByClass(new SingleCondition( "642EHDCS899XKF8P","10009"));
    
    

    通过Map接口传参

    另一种方案可以通过传入HashMap,MayBatis会根据key自动映射到对应的参数。
    下面实现通过流水号和指令类型查询。
    添加一个查询配置selectSingleByMultCondition

    <?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="DAO.SingleTransMapper">
        ...
        <select id="selectSingleByMultCondition" resultType="DTO.SingletransDTO">
        select * from se_singletrans where transno = #{transNo} and commandCode= #{commandCode}
      </select>
    </mapper>
    

    添加对应的方法,传入参数为HashMap<String,Object> param

    public interface SingleTransMapper {
      ...
        SingletransDTO selectSingleByMultCondition(HashMap<String,Object> param);
    }
    

    修改调用新的多条件查询方法

    ...
    //获取单笔映射对象
    SingleTransMapper mapper = session.getMapper(SingleTransMapper.class);
    //根据流水号查询
    HashMap<String,Object> param = new HashMap<String,Object>();
    param.put("transNo","642EHDCS899XKF8P");
    param.put("commandCode","10009");
    SingletransDTO blog = mapper.selectSingle2(param);
    ...
    

    需要注意的是,由于HashMap的key是不区分大小写的,因此需要和配置文件sql的参数大小写一致。

    Param注解

    通过类参数和Map进行多条件查询都需要创建额外的对象,另一种比较好的方式可以通过在方法参数上添加Param注解的方式配置方法参数和SQL参数的映射关系。

    添加一个查询配置selectSingleByParam

    <?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="DAO.SingleTransMapper">
       
       ...
        <select id="selectSingleByParam" resultType="DTO.SingletransDTO">
        select * from se_singletrans where transno = #{param1} and commandCode= #{param2}
      </select>
    </mapper>
    

    对应的映射类添加方法对应的方法,这样MyBatis就知道参数映射规则,就会自动映射,需要注意的数参数和sql中配置的大小写也需要一致。

    
    public interface SingleTransMapper {
        SingletransDTO selectSingle(String transNo);
        SingletransDTO selectSingleByMultCondition(HashMap<String,Object> param);
        SingletransDTO selectSingleByParam(@Param("param1")String transNo, @Param("param2") String commandCode);
    }
    
    

    调用注解传参方法

    ...
    //获取单笔映射对象
    SingleTransMapper mapper = session.getMapper(SingleTransMapper.class);
    SingletransDTO blog = mapper.selectSingleByParam("642EHDCS899XKF8P","10009");
    ...
    

    插入

    在mapper下添加insert表示插入的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">
    <mapper namespace="DAO.SingleTransMapper">
      
      ...
      <insert id="insert" parameterType="DTO.SingletransDTO">
        insert into se_singletrans(ENTERPRISENUM,TRANSNO,COMMANDCODE,STATE) values(#{EnterpriseNum},#{TransNo},#{CommandCode},#{State})
      </insert>
    </mapper>
    

    添加类对应的insert方法

    
    public interface SingleTransMapper {
    
        ...
        int insert(SingletransDTO singletransDTO);
    }
    

    SqlSession默认会开启事务,在insert完成后需要调用SqlSessioncommit()方法提交事务。

    
    try (SqlSession session = sqlSessionFactory.openSession()) {
        SingleTransMapper mapper = session.getMapper(SingleTransMapper.class);
        SingletransDTO singletransDTO = new     SingletransDTO();
        singletransDTO.EnterpriseNum  = "QT330001";
        singletransDTO.TransNo = "MYBATIS.INSERT";
        singletransDTO.CommandCode = "10009";
        int count = mapper.insert(singletransDTO);
        session.commit();
        System.out.println("insert result:" +count);
    }catch (Exception exception)
    {
        System.out.println(exception.getMessage());
    }
    

    我们也可以调用SqlSession openSession(boolean autoCommit)传入参数,自动提交。

    更新

    在mapper下添加update节点表示插入,插入时可以对插入的字段设置条件,达成某条件是该字段才需要更新。

    <?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="DAO.SingleTransMapper">
      
      ...
       <update id="update" parameterType="DTO.SingletransDTO">
        update se_singletrans
        <set>
            <if test="State != null and State!=''"></if>
            STATE=#{State}
        </set>
        where transno = #{TransNo} and commandCode= #{CommandCode}
      </update>
    </mapper>
    

    添加类对应的update方法

    
    public interface SingleTransMapper {
    
        ...
        int update(SingletransDTO singletransDTO);
    }
    

    SqlSession默认会开启事务,和insert一样,在update完成后需要调用SqlSessioncommit()方法提交事务。

    
    try (SqlSession session = sqlSessionFactory.openSession()) {
        SingleTransMapper mapper = session.getMapper(SingleTransMapper.class);
        SingletransDTO singletransDTO = new SingletransDTO();
        singletransDTO.EnterpriseNum = "QT330001";
        singletransDTO.TransNo = "MYBATIS.INSERT";
        singletransDTO.CommandCode = "10009";
        singletransDTO.State = 2;
        int count = mapper.update(singletransDTO);
        session.commit();
        System.out.println("update result:" +count);
    }catch (Exception exception)
    {
        System.out.println(exception.getMessage());
    }
    

    删除

    在mapper下添加delete节点表示删除。

    <?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="DAO.SingleTransMapper">
      
      ...
       
      <delete id="delete">
        delete from se_singletrans where transno = #{TransNo} and commandCode= #{CommandCode}
      </delete>
    </mapper>
    

    添加类对应的delete方法,可以通过参数注解的方式指定参数。

    
    public interface SingleTransMapper {
    
        ...
        int delete(@Param("TransNo")String transNo, @Param("CommandCode") String commandCode);
    }
    

    SqlSession默认会开启事务,在delete完成后需要调用SqlSessioncommit()方法提交事务。

    
    try (SqlSession session = sqlSessionFactory.openSession()) {
        SingleTransMapper mapper = session.getMapper(SingleTransMapper.class);
        int count = mapper.delete("MYBATIS.INSERT","10009");
        session.commit();
        System.out.println("delete result:" +count);
    }catch (Exception exception)
    {
        System.out.println(exception.getMessage());
    }
    

    字段映射

    若字段名和数据库的字段名不一致,可以通过配置进行映射。添加resultMap节点,配置类字段和数据库字段的映射关系,若没有配置的字段,则根据默认MyBatis的映射关系处理,即字段名一样的自动映射,MyBatis会尝试进行类型转换,若转换异常,则可能抛错。我们也可以通过typeHandler自定义自己的类型处理器。

    <?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="DAO.SingleTransMapper">
    
      <resultMap id="singleResultMap" type="DTO.SingletransDTO">
        <result property="TransNo"  column="transNo" />
        <result property="CommandCode" column="commandCode"/>
        <result property="SpecialProperty" typeHandler="CustomTypeHandle" column="SpecialColumn"/>
      </resultMap>
      <select id="selectSingleToReusltMap" resultMap="singleResultMap">
        select * from se_singletrans where transno = #{param1} and commandCode= #{param2}
      </select>
    </mapper>
    

    关于TypeHandle这里不做具体阐述,有兴趣的可以看下MyBatis自定义类型处理器 TypeHandler

    参考文献

    1. Maven添加Oracle的依赖及驱动
    2. MyBatis自定义类型处理器 TypeHandler
  • 相关阅读:
    Azure PowerShell (2) 修改Azure订阅名称
    Windows Azure Platform Introduction (11) 了解Org ID、Windows Azure订阅、账户
    Azure PowerShell (3) 上传证书
    Azure PowerShell (1) PowerShell入门
    Windows Azure Service Bus (2) 队列(Queue)入门
    Windows Azure Service Bus (1) 基础
    Windows Azure Cloud Service (10) Role的生命周期
    Windows Azure Cloud Service (36) 在Azure Cloud Service配置SSL证书
    Android studio 使用心得(一)—android studio快速掌握快捷键
    android 签名、混淆打包
  • 原文地址:https://www.cnblogs.com/Jack-Blog/p/13179382.html
Copyright © 2011-2022 走看看