mybatis入门教程

合集下载

mybatis入门教程(一)(超简单)

mybatis入门教程(一)(超简单)

mybati‎s第一天mybati‎s的基础知识‎课程安排:mybati‎s和spri‎n gmvc通‎过订单商品案例驱动第一天:基础知识(重点,内容量多)对原生态jd‎b c程序(单独使用jd‎b c开发)问题总结mybati‎s框架原理(掌握)mybati‎s入门程序用户的增、删、改、查mybati‎s开发dao‎两种方法:原始dao开‎发方法(程序需要编写‎d a o接口和‎d a o实现类‎)(掌握)mybait‎s的mapp‎e r接口(相当于dao‎接口)代理开发方法‎(掌握)mybati‎s配置文件S‎q lMapC‎onfig.xmlmybati‎s核心:mybati‎s输入映射(掌握)mybati‎s输出映射(掌握)mybati‎s的动态sq‎l(掌握)第二天:高级知识订单商品数据‎模型分析高级结果集映‎射(一对一、一对多、多对多)mybati‎s延迟加载mybati‎s查询缓存(一级缓存、二级缓存)mybait‎s和spri‎n g进行整合‎(掌握)mybati‎s逆向工程1对原生态jd‎bc程序中问‎题总结1.1环境java环境‎:jdk1.7.0_72eclips‎e:indigo‎mysql:5.11.2创建mysq‎l数据导入下边的脚‎本:sql_ta‎ble.sql:记录表结构sql_da‎t a.sql:记录测试数据‎,在实际企业开‎发中,最后提供一个‎初始化数据脚‎本1.3jdbc程序‎使用jdbc‎查询mysq‎l数据库中用‎户表的记录。

创建java‎工程,加入jar包‎:数据库驱动包‎(m ysql5‎.1)上边的是my‎sql驱动。

下边的是or‎a cle的驱‎动。

程序代码:1.4问题总结1、数据库连接,使用时就创建‎,不使用立即释‎放,对数据库进行‎频繁连接开启‎和关闭,造成数据库资‎源浪费,影响数据库性能。

设想:使用数据库连‎接池管理数据‎库连接。

2、将sql语句‎硬编码到ja‎v a代码中,如果sql 语句修改,需要重新编译‎java代码‎,不利于系统维‎护。

mybatis 教程

mybatis 教程

mybatis 教程MyBatis 是一个持久层框架,通过它可以简化数据库操作,提高开发效率。

本教程将介绍 MyBatis 的基本概念、使用方法以及一些实例。

MyBatis 的基本概念有以下几个方面:SQL 映射、查询参数、结果映射以及缓存。

SQL 映射是指将 SQL 语句与相应的数据操作进行映射,MyBatis 提供了 XML 和注解两种方式来配置SQL 映射。

查询参数是指传递给 SQL 语句的参数,可以是基本类型、实体类或者自定义对象。

结果映射是将查询结果映射到 Java 对象中,可以使用注解或者 XML 进行配置。

缓存是将查询的结果缓存起来,提高查询效率。

使用 MyBatis 的步骤如下:1. 引入 MyBatis 的依赖:在项目的 pom.xml 文件中添加MyBatis 的依赖。

2. 配置 MyBatis:创建一个 mybatis-config.xml 文件,配置MyBatis 的一些全局属性和设置。

3. 创建 Mapper 接口:创建一个 Java 接口,定义要执行的SQL 语句。

4. 配置 SQL 映射:在 XML 文件中配置 SQL 语句与 Mapper 接口的映射关系。

5. 使用 MyBatis:在 Java 代码中使用 MyBatis 的 API,进行数据库操作。

下面是一个简单的示例,演示如何使用 MyBatis 进行数据库查询操作:1. 创建 UserMapper 接口:```javapublic interface UserMapper {User getUserById(int id);}```2. 配置 SQL 映射:```xml<mapper namespace="erMapper"><select id="getUserById"resultType="er">SELECT * FROM user WHERE id = #{id}</select></mapper>```3. 使用 MyBatis:```javaSqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);SqlSession sqlSession = sqlSessionFactory.openSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class);User user = userMapper.getUserById(1);```以上示例中,定义了一个 UserMapper 接口,并在 XML 中配置了一个名为 getUserById 的 SQL 查询语句。

MyBatis详解一篇就够啦

MyBatis详解一篇就够啦

MyBatis详解⼀篇就够啦第1章MyBatis框架配置⽂件详解1.1 typeHandlers类型转换器 每当MyBatis 设置参数到PreparedStatement 或者从ResultSet 结果集中取得值时,就会使⽤TypeHandler 来处理数据库类型与java 类型之间转换。

下表描述了默认TypeHandlers1.1.1 ⾃定义类型转换器假设表中字段是int类型,⽽实体类与之对应的属性是boolean类型,此时可以采⽤⾃定义类型转换器进⾏对应(1)实体类1 package com.chenyanbin.beans;23 public class Dept {4 private Integer deptNo;5 private String dname;6 private String loc;7 private boolean flag;8 public Integer getDeptNo() {9 return deptNo;10 }11 public boolean isFlag() {12 return flag;13 }14 public void setFlag(boolean flag) {15 this.flag = flag;16 }17 public void setDeptNo(Integer deptNo) {18 this.deptNo = deptNo;19 }20 public String getDname() {21 return dname;22 }23 public void setDname(String dname) {24 this.dname = dname;25 }26 public String getLoc() {27 return loc;28 }29 public void setLoc(String loc) {30 this.loc = loc;31 }32 }(2) 表中字段(3) 开发⾃定义类型转换器:MyTypeHandler.java继承并实现接⼝:TypeHandler.java1 package com.chenyanbin.util;23 import java.sql.CallableStatement;4 import java.sql.PreparedStatement;5 import java.sql.ResultSet;6 import java.sql.SQLException;78 import org.apache.ibatis.jdbc.Null;9 import org.apache.ibatis.type.JdbcType;10 import org.apache.ibatis.type.TypeHandler;11 /*12 * setParameter:这个⽅法在⽣成SQL语句时才被调⽤13 *14 * getResult:查询结束之后,在将ResultSet数据⾏转换为实体类对象时,通知TypeHandler将当前数据⾏某个字段转换为何种类型15 *16 *17 */18 public class MyTypeHandler implements TypeHandler {1920 public void setParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType) throws SQLException {21 if (parameter==null) { //dept.flag=null insertsql flag设置022 ps.setInt(i, 0);23 return;24 }25 Boolean flag=(Boolean)parameter;26 if (flag==true) {27 ps.setInt(i, 1);28 }29 else {30 ps.setInt(i, 0);31 }32 }3334 public Object getResult(ResultSet rs, String columnName) throws SQLException {35 int flag = rs.getInt(columnName); //1 or 036 Boolean myFlag=Boolean.FALSE;37 if (flag==1) {38 myFlag=Boolean.TRUE;39 }40 return myFlag;41 }4243 public Object getResult(ResultSet rs, int columnIndex) throws SQLException {44 // TODO Auto-generated method stub45 return null;46 }4748 public Object getResult(CallableStatement cs, int columnIndex) throws SQLException {49 // TODO Auto-generated method stub50 return null;51 }5253 }(4) 在MyBatis核⼼配置⽂件注册⾃定义类型转换器:myBatis-config.xml1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE configuration3 PUBLIC "-////DTD Config 3.0//EN"4 "/dtd/mybatis-3-config.dtd">5 <configuration>6 <!-- 属性配置 -->7 <properties resource="config.properties"></properties>8 <!-- 别名配置 -->9 <typeAliases>10 <package name="com.chenyanbin.beans" />13 <!-- 类型处理器 -->14 <typeHandlers>15 <!-- 从java中的Boolean转jdbc中的NUMERIC -->16 <typeHandler handler="com.chenyanbin.util.MyTypeHandler"17 javaType="Boolean" jdbcType="NUMERIC" />18 </typeHandlers>19 <!-- 环境配置 -->20 <environments default="development">21 <!-- 环境配置 -->22 <environment id="development">23 <!-- 事务管理器 -->24 <transactionManager type="JDBC"></transactionManager>25 <!-- 数据源 -->26 <dataSource type="pooled">27 <property name="driver" value="${jdbc.driver}" />28 <property name="url" value="${jdbc.url}" />29 <property name="username" value="${ername}" />30 <property name="password" value="${jdbc.password}" />31 </dataSource>32 </environment>33 </environments>34 <!-- 映射器 -->35 <mappers>36 <package name="com.chenyanbin.dao" />37 </mappers>38 </configuration>config.properties1 jdbc.driver=com.mysql.jdbc.Driver2 jdbc.url=jdbc:mysql://localhost:3306/sam3 ername=root4 jdbc.password=root(5) 创建接⼝:DeptMapper.java1 package com.chenyanbin.dao;23 import java.util.List;4 import com.chenyanbin.beans.Dept;56 public interface DeptMapper {7 public void deptSave(Dept dept);89 public List<Dept> deptFind();10 }(6) DeptMapper.xml1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE mapper3 PUBLIC "-////DTD Mapper 3.0//EN"4 "/dtd/mybatis-3-mapper.dtd">5 <mapper namespace="com.chenyanbin.dao.DeptMapper">6 <insert id="deptSave">7 insert into dept (DEPTNO,DNAME,LOC,flag)8 values(#{deptNo},#{dname},#{loc},#{flag})9 </insert>10 <select id="deptFind" resultType="Dept">11 select deptNo,dname,loc,flag from dept12 </select>13 </mapper>1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE configuration3 PUBLIC "-////DTD Config 3.0//EN"4 "/dtd/mybatis-3-config.dtd">5 <configuration>6 <!-- 属性配置 -->7 <properties resource="config.properties"></properties>8 <!-- 别名配置 -->9 <typeAliases>10 <package name="com.chenyanbin.beans" />11 <package name="com.chenyanbin.dao" />12 </typeAliases>13 <!-- 环境配置 -->14 <environments default="development">15 <!-- 环境配置 -->16 <environment id="development">17 <!-- 事务管理器 -->18 <transactionManager type="JDBC"></transactionManager>19 <!-- 数据源 -->20 <dataSource type="pooled">21 <property name="driver" value="${jdbc.driver}" />22 <property name="url" value="${jdbc.url}" />23 <property name="username" value="${ername}" />24 <property name="password" value="${jdbc.password}" />25 </dataSource>26 </environment>27 </environments>28 <!-- 映射器 -->29 <mappers>32 </configuration>⽅式⼆:myBatis-config.xml1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE mapper3 PUBLIC "-////DTD Mapper 3.0//EN"4 "/dtd/mybatis-3-mapper.dtd">5 <mapper namespace="com.chenyanbin.dao.DeptMapper">6 <insert id="deptSave">7 insert into dept (DEPTNO,DNAME,LOC,flag)8 values(#{deptNo},#{dname},#{loc},#{flag})9 </insert>10 <resultMap type="dept" id="deptMap">11 <result column="flag" property="flag" typeHandler="com.chenyanbin.util.MyTypeHandler"/>12 </resultMap>13 <select id="deptFind" resultType="Dept">14 select deptNo,dname,loc,flag from dept15 </select>16 </mapper>⽅式⼆:DeptMapper.xml(7) 执⾏单元测试:TestMain_01.java1 package com.chenyanbin.test;23 import java.io.IOException;4 import java.io.InputStream;5 import java.util.List;6 import org.apache.ibatis.io.Resources;7 import org.apache.ibatis.session.SqlSession;8 import org.apache.ibatis.session.SqlSessionFactory;9 import org.apache.ibatis.session.SqlSessionFactoryBuilder;10 import org.junit.After;11 import org.junit.Before;12 import org.junit.Test;13 import com.chenyanbin.beans.Dept;14 import com.chenyanbin.dao.DeptMapper;1516 public class TestMain_01 {17 private SqlSession session;1819 @Before20 public void Start() {21 try {22 InputStream inputStream = Resources.getResourceAsStream("myBatis-config.xml");23 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);24 session = factory.openSession();25 } catch (Exception e) {26 e.printStackTrace();27 }28 }2930 @After31 public void end() {32 if (session == null) {33 session.close();34 }35 }3637 @Test38 public void test01() throws IOException {39 Dept d2 = new Dept();40 d2.setDname("上海事业部");41 d2.setLoc("上海");42 d2.setFlag(false);43 session.insert("deptSave", d2);44 mit();45 session.close();46 }4748 @Test49 public void test02() {50 DeptMapper dao=session.getMapper(DeptMapper.class);51 List<Dept> deptList=dao.deptFind();52 System.out.println("ok");53 }5455 }(8) 项⽬⽬录结构1.2 objectFactory 对象⼯⼚ MyBatis 每次创建结果对象的新实例时,它都会使⽤⼀个对象⼯⼚(ObjectFactory)实例来完成。

MyBatis框架基础知识(01)

MyBatis框架基础知识(01)

MyBatis框架基础知识(01)1. MyBatis框架的作用主要作用:简化持久层开发。

持久层:解决项目中的数据持久化处理的相关组件。

使用MyBatis框架实现数据库编程时,只需要指定各个功能对应的抽象方法及需要执行的SQL语句即可。

2. 创建MyBatis项目MyBatis项目可以是本机直接运行的,不一定需要与SpringMVC 框架结合起来一起使用,所以,在创建项目时,只需要创建为jar项目即可。

当项目创建出来之后,需要添加mybatis依赖:<!-- /artifact/org.mybatis/mybatis --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.4</version></dependency>然后,还需要添加MyBatis整合Spring框架的mybatis-spring 依赖:<!-- /artifact/org.mybatis/mybatis-spring --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.4</version></dependency>由于需要整合Spring框架,所以,还需要添加Spring框架的spring-context依赖:<!-- /artifact/org.springframework/spring-context --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.5.RELEASE</version></dependency>其底层实现是基于JDBC的,所以,还需要添加spring-jdbc依赖:<!-- /artifact/org.springframework/spring-jdbc --><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.5.RELEASE</version></dependency>本次将使用MySQL数据库,所以,还需要添加mysql-connector-java依赖:<!-- /artifact/mysql/mysql-connector-java --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.19</version></dependency>在连接数据库时,应该使用数据库连接池,所以,还应该添加commons-dbcp依赖:<!-- /artifact/mons/commons-dbcp2 --><dependency><groupId>mons</groupId><artifactId>commons-dbcp2</artifactId><version>2.7.0</version></dependency>在开发完某个功能后,应该及时检查开发的功能是否可以正常运行,所以,还添加junit单元测试依赖:<!-- /artifact/junit/junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13</version><scope>test</scope></dependency>3. 案例准备工作先登录MySQL控制台,创建名为tedu_ums的数据库:CREATE DATABASE tedu_ums;并使用这个数据库:USE tedu_ums;在这个数据库中,创建一张用户数据表t_user,表中应该包含以下字段:id、用户名(username)、密码(password)、年龄(age)、手机号码(phone)、电子邮箱(email):CREATE TABLE t_user (id int AUTO_INCREMENT,username varchar(20) NOT NULL UNIQUE,password varchar(20) NOT NULL,age int,phone varchar(20),email varchar(50),PRIMARY KEY (id)) DEFAULT CHARSET=utf8;4. 测试项目是否可以正常运行在src/test/java下,创建cn.tedu.spring包,并在这个包中创建ProjectTests测试类,在测试类添加空白的测试方法,以测试JUnit环境是否正常:package cn.tedu.spring;import org.junit.Test;public class ProjectTests {@Testpublic void contextLoads() {System.out.println("ProjectTests.contextLoads()");}}凡是在src/test下的文件,都不会参与项目最终打包、部署,所以,一般在编写单元测试时,对代码规范要求并不那么严格,但是,仍应该尽量遵循开发规范。

MyBatis新手入门

MyBatis新手入门

第一章用MyBatis实现增删查改第一步下载打开http://mybatis.github.io/看这里使劲点它!跳转到这个页面再使劲点它就会跳转到github仓库,看到这个界面注意:这里只是mybatis的一些发表信息,点一下它终于来到这个下载地方了,特么的好累动一下你的手指,滚动到最下方点它转到到这里看,出来了吧,找的我那么辛苦,当时恨不得点烂它!解压出来,进去看到第二步搭建和配置这个目录结构就对了,用MyEclipse创建一个Web Project,把mybatis-3.2.8.jar拷贝粘贴到自己创建的MyEclipse项目中的lib下(不知道哪里是MyEclipse项目的lib文件夹的人建议转行别写代码了),我的结构是这样的为什么里面还多了一个mysql-connector-java-5.1.6-bin.jar呢?它是干嘛用的呢?我顺手拷贝进去的,看到这个mysql的jdbc驱动大家应该明白我要测试用的数据库是mysql,自己随意,用什么数据库就拷贝什么驱动。

MyBatis里面是没有的,网上多得是,自己要什么驱动就去下载什么驱动。

可以动手了动手去src下创建3个包,我是这样子的我个人比较喜欢收缩着看,比较简洁,看这里点它- Package Presentation – Hierarchial,就变成这样这样命名有自己的含义,我打算inter包专门放接口(Interface),model包放Bean,test包放测试类。

创建一个叫mybatis的数据库,在里面创建一个表叫user,表user的结构如下懒人请复制:CREATE TABLE IF NOT EXISTS `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`userName` varchar(50) DEFAULT NULL,`userAge` int(11) DEFAULT NULL,`userAddress` varchar(200) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=7 ; 顺便弄写数据进去INSERT INTO `user` (`id`, `userName`, `userAge`, `userAddress`) VALUES (1, '余小龙', 10, '人民广场'),(3, 'lisiwei', 80, '中山大学南方学院123'),(5, '麦家潮', 20, '中国'),(6, '周杰伦', 30, '北京');在包model下创建一个User类,根据数据库表在类中创建相应的成员变量,如下:private int id;private String userName;private String userAge;private String userAddress;右击鼠标——Source——Generate Getter and Setter点全选——OK,变成这样子创建完User类,接下来在同一个包(model)下创建一个User.xml文件,填以下内容:头部的声明代码太麻烦?懒人请复制<!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd">接下来,定义一个查询方法,根据用户ID查询User表中的某一条记录,在<mapper></mapper>里面写<select>标签是MyBatis的查询标签,id=”selectUserById”随便改,但是,要记住哦,等下会用到的parameterType是参数类型的意思,resultType是结果类型的意思,把查询的结果封装成一个User对象,有人问过我,为什么我经常在一些表名两边加上反冒号`,如:,知道的请跳过以下内容:在mysql中,有些关键字是不能用的,例如order、database、table等等,我在表名user两端加上`,作用就是告诉mysql,我写这个user不是想要调用mysql关键字,这个user仅仅代表我自己定义的数据库表名,mysql的关键字太多,我不能确定user是不是其中之一,不想去查,所以加上``了事,那么mysql 就不管user是不是mysql关键字,就算不小心user真的是关键字,也当user 不起作用,忽略它。

MyBatis学习总结

MyBatis学习总结

MyBatis学习总结(一)——MyBatis快速入门一、Mybatis介绍MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架。

MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。

MyBatis可以使用简单的XML或注解用于配置和原始映射,将接口和Java的POJO (Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。

二、mybatis快速入门2.1、准备开发环境1、创建测试项目,普通java项目或者是JavaWeb项目均可,如下图所示:2、添加相应的jar包【mybatis】mybatis-3.1.1.jar【MYSQL驱动包】mysql-connector-java-5.1.7-bin.jar3、创建数据库和表,针对MySQL数据库SQL脚本如下:1createdatabase mybatis;2use mybatis;3CREATETABLE users(id INTPRIMARYKEY AUTO_INCREMENT, NAME VARCHAR(20), age INT);4INSERTINTO users(NAME, age) VALUES('孤傲苍狼', 27);5INSERTINTO users(NAME, age) VALUES('白虎神皇', 27);将SQL脚本在MySQL数据库中执行,完成创建数据库和表的操作,如下:到此,前期的开发环境准备工作全部完成。

2.2、使用MyBatis查询表中的数据1、添加Mybatis的配置文件conf.xml在src目录下创建一个conf.xml文件,如下图所示:conf.xml文件中的内容如下:1<?xml version="1.0" encoding="UTF-8"?>2<!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN" "/dtd/mybatis-3-config.dtd">3<configuration>4<environments default="development">5<environment id="development">6<transactionManager type="JDBC"/>7<!-- 配置数据库连接信息 -->8<dataSource type="POOLED">9<property name="driver" value="com.mysql.jdbc.Driver"/>10<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/> 11<property name="username" value="root"/>12<property name="password" value="XDP"/>13</dataSource>14</environment>15</environments>1617</configuration>2、定义表所对应的实体类,如下图所示:User类的代码如下:1package me.gacl.domain;23/**4 * @author gacl5 * users表所对应的实体类6*/7publicclass User {89//实体类的属性和表的字段名称一一对应10privateint id;11private String name;12privateint age;1314publicint getId() {15return id;16 }1718publicvoid setId(int id) {19this.id = id;20 }2122public String getName() {23return name;24 }2526publicvoid setName(String name) { = name;28 }2930publicint getAge() {31return age;32 }3334publicvoid setAge(int age) {35this.age = age;36 }3738 @Override39public String toString() {40return "User [id=" + id + ", name=" + name + ", age=" + age + "]";41 }42 }3、定义操作users表的sql映射文件userMapper.xml创建一个me.gacl.mapping包,专门用于存放sql映射文件,在包中创建一个userMapper.xml文件,如下图所示:userMapper.xml文件的内容如下:1<?xml version="1.0" encoding="UTF-8" ?>2<!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd">3<!-- 为这个mapper指定一个唯一的namespace,namespace的值习惯上设置成包名+sql映射文件名,这样就能够保证namespace的值是唯一的4例如namespace="erMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除后缀)5-->6<mapper namespace="erMapper">7<!-- 在select标签中编写查询的SQL语句,设置select标签的id属性为getUser,id属性值必须是唯一的,不能够重复8使用parameterType属性指明查询时使用的参数类型,resultType属性指明查询返回的结果集类型9 resultType="er"就表示将查询结果封装成一个User类的对象返回10 User类就是users表所对应的实体类11-->12<!--13根据id查询得到一个user对象14-->15<select id="getUser" parameterType="int"16 resultType="er">17 select * from users where id=#{id}18</select>19</mapper>4、在conf.xml文件中注册userMapper.xml文件1<?xml version="1.0" encoding="UTF-8"?>2<!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd">3<configuration>4<environments default="development">5<environment id="development">6<transactionManager type="JDBC"/>7<!-- 配置数据库连接信息 -->8<dataSource type="POOLED">9<property name="driver" value="com.mysql.jdbc.Driver"/>10<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>11<property name="username" value="root"/>12<property name="password" value="XDP"/>13</dataSource>14</environment>15</environments>1617<mappers>18<!-- 注册userMapper.xml文件,19 userMapper.xml位于me.gacl.mapping这个包下,所以resource写成me/gacl/mapping/userMapper.xml-->20<mapper resource="me/gacl/mapping/userMapper.xml"/>21</mappers>2223</configuration>5、编写测试代码:执行定义的select语句创建一个Test1类,编写如下的测试代码:package me.gacl.test;import java.io.IOException;import java.io.InputStream;import java.io.Reader;import er;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;publicclass Test1 {publicstaticvoid main(String[] args) throws IOException {//mybatis的配置文件String resource = "conf.xml";//使用类加载器加载mybatis的配置文件(它也加载关联的映射文件)InputStream is =Test1.class.getClassLoader().getResourceAsStream(resource);//构建sqlSession的工厂SqlSessionFactory sessionFactory = newSqlSessionFactoryBuilder().build(is);//使用MyBatis提供的Resources类加载mybatis的配置文件(它也加载关联的映射文件) //Reader reader = Resources.getResourceAsReader(resource);//构建sqlSession的工厂//SqlSessionFactory sessionFactory = newSqlSessionFactoryBuilder().build(reader);//创建能执行映射文件中sql的sqlSessionSqlSession session = sessionFactory.openSession();/*** 映射sql的标识字符串,* erMapper是userMapper.xml文件中mapper标签的namespace属性的值,* getUser是select标签的id属性值,通过select标签的id属性值就可以找到要执行的SQL*/String statement = "erMapper.getUser";//映射sql的标识字符串//执行查询返回一个唯一user对象的sqlUser user = session.selectOne(statement, 1);System.out.println(user);}}执行结果如下:可以看到,数据库中的记录已经成功查询出来了。

Mybatis教程及使用配置

Mybatis教程及使用配置

Mybatis教程及使用配置2013-11-22 | 所属分类:Mybatis 教程入门配置12_17一.Mybatis简介MyBatis由Clinton Begin 在2002 年创建,其后,捐献给了Apache基金会,成立了iBatis 项目。

2010 年5 月,将代码库迁至Google Code,并更名为MyBatis。

MyBatis 是一个可以自定义SQL、存储过程和高级映射的持久层框架。

MyBatis 只使用简单的XML 和注解来配置和映射基本数据类型、Map 接口和POJO 到数据库记录。

相对Hibe rnate和Apache OJB等“一站式”ORM解决方案而言,Mybatis 是一种“半自动化”的ORM实现。

二.从JDBC到Mybatis1. JDBC查询数据库数据,一般需要以下七个步骤:(1)加载JDBC驱动(2)建立并获取数据库连接(3)创建 JDBC Statements 对象(4)设置SQL语句的传入参数(5)执行SQL语句并获得查询结果(6)对查询结果进行转换处理并将处理结果返回(7)释放相关资源(关闭Connection,关闭Statement,关闭ResultSet)实现JDBC有七个步骤,哪些步骤是可以进一步封装的,减少我们开发的代码量?2. JDBC演变到Mybatis过程第一步优化:连接获取和释放问题描述:通过JDBC的方式数据库连接频繁的开启和关闭本身就造成了资源的浪费,影响系统的性能;但是现在连接池多种多样,可能存在变化,有可能采用DBCP的连接池,也有可能采用容器本身的JNDI数据库连接池。

解决问题:数据库连接的获取和关闭我们可以使用数据库连接池来解决资源浪费的问题,通过连接池就可以反复利用已经建立的连接去访问数据库了,减少连接的开启和关闭的时间。

同时通过DataSource进行隔离解耦,统一从DataSource里面获取数据库连接,DataSource 具体由DBCP实现还是由容器的JNDI实现都可以,将DataSource的具体实现通过让用户配置来应对变化。

mybatis从入门到精通

mybatis从入门到精通

1、对原生态的jdbc程序问题总结1.1 jdbc程序:使用jdbc查询mysql数据库中用户表的记录1.2 问题:1)数据库连接使用时创建、不使用时就释放:对数据库进行频繁的连接的创建和释放,造成数据库资源浪费,影响数据库性能---------------使用数据库连接池管理数据库连接2)将sql语句硬编码到java代码中,如果sql语句修改,需要重新编译java 代码,不利于系统维护-------------将sql语句配置在xml配置文件中,即使sql变化,不需要对java代码进行重新编译3)向prepareStatement中设置参数,对占位符号位置和设置参数值,硬编码在java代码中,不利于系统维护-------------------将sql语句及占位符和参数全部配置在xml文件中4)从resultSet中遍历结果集数据时,存在硬编码,将获取表的字段进行硬编码,不利于系统维护----------------------将结果集自动映射成java对象2、mybatis框架原理2.1 mybatis是什么?mybatis是一个持久层框架,是apache下的顶级项目github下:https:///mybatis/mybatis-3/releasesmybatis让程序员将主要精力放在sql上,通过mybatis提供的映射方式,自由灵活生成满足sql需要的sql语句mybatis可以将向preparestatement输入的参数自动进行输入映射,将查询结果集灵活映射成java对象(输出映射)。

2.2 mybatis框架\3、mybatis入门程序3.1 需求根据主键查询用户信息根据用户名模糊查询用户信息怎删改查.....3.2 mybati运行环境(jar包):从https:///mybatis/mybatis-3/releases 下载lib下:依赖包mybatis-3.4.1.jar:核心包3.3 log4j.propertie s#Global logging configurationlog4j.rootLogger=ERROR, stdout#MyBatis logging configuration....mybatis.example.BlogMapper=TRACE#Console output...log4j.appender.stdout=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%5p[%t]-%m%n3.4 工程目录结构3.5 根据用户id查询用户信息、通过用户名模糊查询用户信息3.5.1 编写映射文件(包括对应的实体类:User.java)映射文件命名:User.xml(原始的ibatis命名方式),mapper代理的映射文件名称叫做XXXMapper.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><!--namespace命名空间,作用就是对sql进行分类化管理,理解sql隔离注意:将来如果使用mapper代理方法开发,namespace有特殊作用--><mapper namespace="test"><!--在映射文件中配置许多sql语句--><!--通过select执行数据库查询,id:标识映射文件中的sql,成为statement的id,将sql语句封装到mapperStatement对象中,所以将id成为statement的idparameterType:输入参数的类型#{}:表示一个占位符#{id}:其中id表示输入的参数,参数名就是id,如果输入参数是简单类型,#{}中的参数名可以任意resultType:指定sql输出结果所映射的对象类型--><select id="findUserById" parameterType="int"resultType="er">SELECT * FROM USER WHERE uid=#{id}</select><!--${}:表示拼接sql串,将接收到的参数的内容不加任何修饰拼接到sql中--><select id="findUserByName" parameterType="ng.String"resultType="er">SELECT * FROM USER WHERE name LIKE '%${value}%'</select></mapper>3.5.2 将映射文件加载到SqlMapConfig配置文件中<!--加载映射文件--><mappers><mapper resource="sqlmap/User.xml"/></mappers>3.5.3 程序编写@Testpublicvoid findUserByIdTest()throws IOException{// mybatis配置文件String resource ="SqlMapConfig.xml";InputStream input =Resources.getResourceAsStream(resource);// 创建会话工厂SqlSessionFactory sqlSessionFactory =new SqlSessionFactoryBuilder().build(input);// 通过工厂得到SqlSessionSqlSession sqlSession = sqlSessionFactory.openSession();// 通过SqlSession操作数据库User user = sqlSession.selectOne("test.findUserById",23);System.out.println(user.getName());// 释放资源sqlSession.close();}// 根据name查询用户信息,得到一条记录的结果@Testpublicvoid findUserByNameTest()throws IOException{// mybatis配置文件String resource ="SqlMapConfig.xml";InputStream input =Resources.getResourceAsStream(resource);// 创建会话工厂SqlSessionFactory sqlSessionFactory =new SqlSessionFactoryBuilder().build(input);// 通过工厂得到SqlSessionSqlSession sqlSession = sqlSessionFactory.openSession();// 通过SqlSession操作数据库List<User> list = sqlSession.selectList("test.findUserByName","李");System.out.println(list.size());// 释放资源sqlSession.close();}3.6 插入用户信息3.6.1 User.xml映射文件:<!--添加用户parameterType:制定输入参数类型是pojo#{}:中指定pojo属性名,接收到pojo对象的属性值,mybatis通过OGNL获取对象的属性值--><insert id="insertUser" parameterType="er">insert into user(username,password) value(#{username},#{password}) </insert>3.6.2 测试代码:@Testpublicvoid insertUserTest()throws IOException{// mybatis配置文件String resource ="SqlMapConfig.xml";InputStream input =Resources.getResourceAsStream(resource);// 创建会话工厂SqlSessionFactory sqlSessionFactory =new SqlSessionFactoryBuilder().build(input);// 通过工厂得到SqlSessionSqlSession sqlSession = sqlSessionFactory.openSession();// 通过SqlSession操作数据库User user =new User();user.setUsername("ll");user.setPassword("123456");sqlSession.insert("test.insertUser",user);//提交事务mit();// 释放资源sqlSession.close();}3.7 自增主键返回mysql自增主键,执行insert提交之前自动生成一个自增主键。

如何快速学习使用mybatis以及总结

如何快速学习使用mybatis以及总结

如何快速学习使用mybatis以及总结第一步让我来介绍下初学者怎么快速更好的使用mybatis这个框架使用mybatis的话,每个Dao就对于一个相应的xml文件,我来给个例子个大家看,先要配置好环境。

在application.xml里面<!-- c3p0 connection poolconfiguration 数据库的配置 --><bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="${jdbc.driverClass}" /><!-- 数据库驱动 --><property name="jdbcUrl"value="${jdbc.url}" /><!-- 连接URL串 --><property name="user"value="${er}" /><!-- 连接用户名--><property name="password"value="${jdbc.password}" /><!-- 连接密码--><property name="initialPoolSize"value="${jdbc.initialPoolSize}" /><!-- 初始化连接池时连接数量为5个 --><property name="minPoolSize"value="${jdbc.minPoolSize}" /><!-- 允许最小连接数量为5个 --><property name="maxPoolSize" value="${jdbc.maxPoolSize}" /><!-- 允许最大连接数量为20个 --><propertyname="numHelperThreads" value="20" /><!-- 允许最大连接数量为20个 --><property name="maxStatements" value="100" /><!-- 允许连接池最大生成100个PreparedStatement对象 --><property name="maxIdleTime" value="3600" /><!-- 连接有效时间,连接超过3600秒未使用,则该连接丢弃 --><property name="acquireIncrement" value="2" /><!-- 连接用完时,一次产生的新连接步进值为2 --><propertyname="acquireRetryAttempts" value="5" /><!-- 获取连接失败后再尝试10次,再失败则返回DAOException异常 --><propertyname="acquireRetryDelay" value="600" /><!-- 获取下一次连接时最短间隔600毫秒,有助于提高性能 --><propertyname="testConnectionOnCheckin"value="true" /><!-- 检查连接的有效性,此处小弟不是很懂什么意思 --><propertyname="idleConnectionTestPeriod"value="1200" /><!-- 每个1200秒检查连接对象状态 --><property name="checkoutTimeout" value="10000" /><!-- 获取新连接的超时时间为10000毫秒 --></bean><!-- 创建SqlSessionFactory,同时指定数据源 --><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFact oryBean"><property name="dataSource" ref="dataSource" /></bean><!-- 配置事务管理器 --><bean id="transactionManager"class="org.springframework.jdbc.dat asource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /></bean><!--创建数据映射器,数据映射器必须为接口 --><beanclass="org.mybatis.spring.mapper.Mappe rScannerConfigurer"><property name="annotationClass" value="org.springframework.stereotype.Repository" /><property name="basePackage" value="com.shishuo.studio.dao" /></bean>然后我在dao层写个类package com.shishuo.studio.dao;import java.util.List;importorg.apache.ibatis.annotations.Param;importorg.springframework.stereotype.Reposito ry;importcom.shishuo.studio.entity.TagSkill;importcom.shishuo.studio.entity.vo.TagSkillVo;@Repositorypublic interface TagSkillDao {/*** 增加** @param tagSkill* @return*/public int addTagSkill(TagSkill tagSkill);/*** 删除** @param skillId* @return*/public int deleteTagSkill(@Param("skillId") long skillId);/**** 通过SkillId修改名字*/public int updateNameBySkillId(@Param("skillId") long skillId,@Param("name") String name);/*** 通过Id查询** @param skillId* @return*/public TagSkillVo getTagSkillByTagId(@Param("skillId") long skillId);/*** 通过名字查询** @param name* @param rows* @return*/public TagSkillVo getTagSkillByName(@Param("name") String name);/*** 通过userId得到所有所有自己的技能** @param userId* @return*/public List<TagSkillVo> getTagSkillListByUserId(@Param("userId") long userId);}然后再就是对应的XML文件TagSkill.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><mappernamespace="com.shishuo.studio.dao.Tag SkillDao"><!--############################## --><!-- ###### 增加 ###### --><!--############################## --><insert id="addTagSkill" parameterType="com.shishuo.studio.entit y.TagSkill">insert into tag_skill(name,content,status,createTime)values(#{name},#{content},#{status},#{create Time})<selectKey resultType="long" keyProperty="skillId">SELECT LAST_INSERT_ID()</selectKey></insert><!--############################## --><!-- ###### 删除 ###### --><!--############################## --><delete id="deleteTagSkill" parameterType="Long">delete from tag_skill where skillId=#{skillId}</delete><!--############################## --><!-- ###### 修改 ###### --><!--############################## --><update id="updateNameBySkillId">update tag_skill set name=#{name} where skillId=#{skillId}</update><!--############################## --><!-- ###### 查询 ###### --><!--############################## --><select id="getTagSkillByTagId" parameterType="Long"resultType="com.shishuo.studio.entit y.vo.TagSkillVo">select * from tag_skill where skillId=#{skillId}</select><select id="getTagSkillByName"resultType="com.shishuo.studio.entit y.vo.TagSkillVo">select * from tag_skill where name=#{name}</select><select id="getTagSkillListByUserId"resultType="com.shishuo.studio.entit y.vo.TagSkillVo">SELECTtags.skillId,,tags.content,tags.st atus,tags.createTime FROM shishuo.tag_skilltags,shishuo.teacher_skill teas where tags.skillId=teas.tagSkillId and userId=#{userId};</select></mapper>使用经验1、要记得在TagSkillDao这个类前添加@Repository这个注解,实体的意思2、你发现了没有,在xml文件里面的id 在那个dao层类里面对应的方法名,然后就是在那个XML文件里面,resultType这个参数里面和对应方法里面的返回数据类型想匹配,记住,如果方法返回是int,记得写Internet,是包装类型,不然会出错的,如果是返回对象的话,或者返回一个对象的集合,resultType 里面就要写这个对象,如果是没有返回的可以不需要写,在dao层里面的方法需要传参数的话,需要写parameterType,但是一定要记住是包装类型,不是基本数据类型,在dao层里面的方法如果是要增加,就传一个对象过来,不需要写注解,如果是通过Id删除的话,比如public int deleteTagSkill(@Param("skillId") long skillId);我们在xml文件里面<delete id="deleteTagSkill" parameterType="Long">delete from tag_skill where skillId=#{skillId}</delete>public int deleteTagSkill(@Param("skillId") long skillId);这个#{skillId}就相当于我们函数里面的参数skillId,其它的增删改查都类似。

Mybatis新手教程之简单入门

Mybatis新手教程之简单入门

Mybatis新⼿教程之简单⼊门1、Mybatis概述 MyBatis 是⽀持普通 SQL 查询(相⽐较于Hibernate的封装,Mybatis是半⾃动化的JDBC封装,⼀个特点就是Mybatis执⾏的SQL查询语句需要⾃⼰在配置⽂件中写),存储过程和⾼级映射的优秀持久层框架。

MyBatis 消除了⼏乎所有的 JDBC 代码和参数的⼿⼯设置以及对结果集的检索。

MyBatis 可以使⽤简单的XML 或注解⽤于配置和原始映射,将接⼝和 Java 的 POJO(Plain Old Java Objects,普通的Java 对象)映射成数据库中的记录。

2、Mybatis原理解析下⾯以Mybatis简单的执⾏流程 1、加载mybatis全局配置⽂件(数据源、mapper映射⽂件等),解析配置⽂件,MyBatis基于XML配置⽂件⽣成Configuration,和⼀个个MappedStatement(包括了参数映射配置、动态SQL语句、结果映射配置),其对应着<select | update | delete | insert>标签项。

2、SqlSessionFactoryBuilder通过Configuration对象⽣成SqlSessionFactory,⽤来开启SqlSession。

3、SqlSession对象完成和数据库的交互: a、⽤户程序调⽤mybatis接⼝层api(即Mapper接⼝中的⽅法) b、SqlSession通过调⽤api的Statement ID找到对应的MappedStatement对象 c、通过Executor(负责动态SQL的⽣成和查询缓存的维护)将MappedStatement对象进⾏解析,sql参数转化、动态sql拼接,⽣成jdbc Statement对象 d、JDBC执⾏sql。

e、借助MappedStatement中的结果映射关系,将返回结果转化成HashMap、JavaBean等存储结构并返回。

mybatis的使用方法

mybatis的使用方法

mybatis的使用方法
MyBatis是一个开源的持久层框架,它可以为Java应用程序提供数据库访问的解决方案。

MyBatis优化了Java应用程序与数据库之间的通信过程,提高了应用程序的性能和可维护性。

下面是MyBatis 的使用方法:
1. 配置数据源
在MyBatis中,需要配置数据源来连接数据库。

可以使用JNDI 或者直接在mybatis-config.xml文件中配置数据源。

在该文件中,还可以配置数据库的基本信息,如driver、url、username等。

2. 定义Mapper
Mapper是MyBatis中最重要的组成部分,它用于定义Java对象和数据库表之间的映射关系。

可以使用注解或XML来定义Mapper。

3. 编写SQL语句
在Mapper中,需要编写SQL语句来对数据库进行操作。

可以使用MyBatis提供的动态SQL语句来编写更加灵活的SQL。

4. 执行SQL语句
在Java应用程序中,可以通过MyBatis提供的SqlSession来执行SQL语句。

可以使用SqlSession的方法来进行增删改查等操作。

5. 处理结果集
执行SQL语句后,需要将结果集映射到Java对象中。

可以使用MyBatis提供的ResultMap来进行结果集的映射。

可以使用注解或XML 来定义ResultMap。

以上就是MyBatis的基本使用方法。

通过MyBatis,可以使Java 应用程序更加简洁、高效。

mybatis对数据库的基本操作步骤

mybatis对数据库的基本操作步骤

mybatis对数据库的基本操作步骤MyBatis是一种优秀的持久层框架,它的主要目的是简化数据库操作的过程,提高开发效率。

下面是MyBatis对数据库的基本操作步骤:1. 引入MyBatis依赖:在项目的pom.xml文件中,加入MyBatis的依赖项。

例如:```xml<dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.5</version></dependency>```2. 配置数据库连接信息:在项目的配置文件中,添加数据库连接的配置信息。

例如,在`application.properties`文件中添加如下配置:```propertiesspring.datasource.url=jdbc:mysql://localhost:3306/mydbername=rootspring.datasource.password=root```3. 创建Mapper接口:创建一个Mapper接口,用于定义数据库操作的接口。

例如:```javapublic interface UserMapperUser getUserById(int id);void insertUser(User user);void updateUser(User user);void deleteUser(int id);```4. 创建Mapper映射文件:创建一个Mapper映射文件,用于定义SQL语句和与之对应的Mapper接口方法。

例如,在`UserMapper.xml`文件中定义如下内容:```xmlSELECT * FROM user WHERE id=#{id}</select>INSERT INTO user(id, name) VALUES(#{id}, #{name})</insert>UPDATE user SET name=#{name} WHERE id=#{id}</update><delete id="deleteUser" parameterType="int">DELETE FROM user WHERE id=#{id}</delete></mapper>```5. 创建数据库实体类:创建一个Java类,用于表示数据库表的实体类。

mybatis的使用流程

mybatis的使用流程

Mybatis的使用流程什么是MybatisMybatis是一个Java持久层框架,它可以将Java对象与数据库表进行映射,简化了数据库操作的编写过程。

使用Mybatis,可以通过定义XML配置文件或使用注解的方式来完成数据库操作。

Mybatis的使用流程使用Mybatis可以分为以下几个步骤:1.创建项目和引入依赖:首先需要创建一个Java项目,并在项目的配置文件中引入Mybatis的依赖。

2.定义数据对象:在Java代码中定义与数据库表对应的数据对象,包括属性和对应的getter和setter方法。

3.创建Mybatis配置文件:创建一个名为mybatis-config.xml的配置文件,配置数据库连接信息和Mybatis的相关设置。

4.创建映射文件:创建一个名为xxxMapper.xml的映射文件,为每个操作定义对应的SQL语句。

5.创建映射接口:创建一个接口,其中定义了与映射文件中SQL语句对应的方法。

6.配置映射关系:在Mybatis配置文件中,配置映射文件和映射接口的对应关系。

7.获取SqlSessionFactory:使用Mybatis提供的工具类创建一个SqlSessionFactory对象,用于创建SqlSession对象。

8.获取SqlSession:通过SqlSessionFactory的openSession方法获取一个SqlSession对象。

9.调用映射接口:通过SqlSession对象调用映射接口中定义的方法,执行SQL语句。

10.提交事务:在执行完所有的数据库操作后,调用SqlSession的commit方法提交事务。

11.关闭SqlSession:在使用完SqlSession之后,调用close方法关闭SqlSession。

Mybatis的配置文件示例```xml <environments default=。

mybatis教程从入门到精通

mybatis教程从入门到精通

mybatis教程从入门到精通什么是mybatisMyBatis是支持普通SQL查询,存储过程和高级映射的优秀持久层框架。

MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。

MyBatis使用简单的XML或注解用于配置和原始映射,将接口和Java的POJOs(Plan Old Java Objects,普通的Java对象)映射成数据库中的记录.orm工具的基本思想无论是用过的hibernate,mybatis,你都可以法相他们有一个共同点:1. 从配置文件(通常是XML配置文件中)得到sessionfactory.2. 由sessionfactory 产生session3. 在session 中完成对数据的增删改查和事务提交等.4. 在用完之后关闭session 。

5. 在java 对象和数据库之间有做mapping 的配置文件,也通常是xml 文件。

mybatis实战教程(mybatis in action)之一:开发环境搭建mybatis 的开发环境搭建,选择: eclipse j2ee 版本,mysql 5.1 ,jdk 1.7,mybatis3.2.0.jar包。

这些软件工具均可以到各自的官方网站上下载。

首先建立一个名字为MyBaits 的dynamic web project1. 现阶段,你可以直接建立java 工程,但一般都是开发web项目,这个系列教程最后也是web的,所以一开始就建立web工程。

2. 将mybatis-3.2.0-SNAPSHOT.jar,mysql-connector-java-5.1.22-bin.jar 拷贝到web工程的lib 目录.3. 创建mysql 测试数据库和用户表,注意,这里采用的是utf-8 编码创建用户表,并插入一条测试数据程序代码程序代码Create TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`userName` varchar(50) DEFAULT NULL,`userAge` int(11) DEFAULT NULL,`userAddress` varchar(200) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;Insert INTO `user` VALUES ('1', 'summer', '100', 'shanghai,pudong');到此为止,前期准备工作就完成了。

MyBatis使用方法

MyBatis使用方法

MyBatis使用方法使用MyBatis的基本步骤如下:1. 引入MyBatis的依赖:在项目的pom.xml文件中添加MyBatis的依赖,或者将其添加到项目的构建路径中。

2.配置数据源:在项目的配置文件中配置数据库的连接信息,包括数据库驱动类,URL,用户名和密码等。

3. 创建数据模型:创建Java类来表示数据库中的表和字段。

可以使用注解或XML配置来映射Java类和数据库表。

4. 创建Mapper接口:创建一个接口来定义数据库操作的方法。

每个方法都对应一个SQL语句,可以使用注解或XML配置来定义SQL语句。

5. 创建Mapper映射文件:如果使用XML配置来定义SQL语句,需要创建一个与Mapper接口同名的XML文件,并在其中定义SQL语句。

6. 创建SqlSessionFactory:使用MyBatis提供的配置文件和数据源信息创建一个SqlSessionFactory对象。

SqlSessionFactory是MyBatis的核心接口,用于创建SqlSession对象。

7. 创建SqlSession:使用SqlSessionFactory创建SqlSession对象。

SqlSession是与数据库交互的入口,可以通过它执行SQL语句。

8. 执行SQL语句:使用SqlSession对象调用Mapper接口的方法来执行SQL语句。

MyBatis会根据Mapper接口的定义和配置文件中的SQL 语句,自动执行相应的操作。

9. 处理结果:根据SQL语句的类型,可以通过SqlSession的一些方法来获取查询结果。

对于更新和删除操作,可以通过返回的整数值来判断操作是否成功。

10. 关闭SqlSession:在使用完SqlSession后,需要手动关闭它。

可以使用try-with-resources语句来确保SqlSession被正确关闭。

除了上述基本步骤外,MyBatis还提供了一些高级功能,如动态SQL,一对一和一对多关系的映射,缓存等。

mybatis入门教程-Mybatis简介与原理

mybatis入门教程-Mybatis简介与原理

【持久化框架】Mybatis简介与原理--夜半什么是Mybatis资料官网:https://mybatis.github.io/mybatis-3/zh/index.html/MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。

iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。

MyBatis 提供的持久层框架包括SQL Maps和Data Access Objects(DAO)。

MyBatis 是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架。

MyBatis 避免了几乎所有的JDBC 代码和手工设置参数以及抽取结果集。

MyBatis使用简单的XML 或注解来配置和映射基本体,将接口和Java 的POJOs(Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。

1、mybatis ibatis2、主要是做数据库操作,使用java操作数据库,dao[持久化]技术知识点1、概念2、基本CRUD标签3、动态sql4、一对多,多对一关系5、了解注解式配置学习内容1、理解什么是mybatis,以及mybatis的应用场景2、使用mybatis开发demo3、熟悉mybatis的配置文件,以后spring的时候,没有用。

4、会使用mybatis实现简单增删改查①Insert delete update select 标签使用ORM对象关系映射(英语:(Object Relational Mapping,简称ORM,或O/RM,或O/R mapping),是一种程序技术,用于实现面向对象编程语言里不同类型系统的数据之间的转换。

从效果上说,它其实是创建了一个可在编程语言里使用的--“虚拟对象数据库”。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

mybatis入门教程
MyBatis是一种开源的持久层框架,它可以帮助我们简化数据库操作的过程。

本教程将介绍如何使用MyBatis进行基本的数据访问操作。

第一步:创建数据库和表
首先,我们需要创建一个数据库和一个表来存储数据。

假设我们创建了一个名为"mybatis_demo"的数据库,并在其中创建了一个名为"users"的表,该表包含id、name和age三个字段。

第二步:引入MyBatis依赖
在使用MyBatis之前,我们需要在项目的pom.xml文件中引入MyBatis的依赖。

可以在Maven仓库中找到最新的MyBatis版本,并将其添加到pom.xml文件中。

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
第三步:创建数据源配置文件
在src/main/resources目录下创建一个名为"mybatis-config.xml"的文件,并在其中配置数据源信息。

以下是一个示例配置:
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis_demo"/>
<property name="username" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<!-- 这里可以配置Mapper接口所在的包 -->
</mappers>
</configuration>
注意:在实际项目中,我们通常会将数据库连接信息配置在外部的配置文件中,而不是直接写在mybatis-config.xml文件中。

第四步:创建实体类和Mapper接口
public class User
private int id;
private String name;
private int age;
// 省略getter和setter方法
在同一个包中创建一个名为"UserMapper"的接口,用于定义与用户相关的数据库操作方法。

public interface UserMapper
User getUserById(int id);
void insertUser(User user);
void updateUser(User user);
void deleteUser(int id);
第五步:创建Mapper映射文件
<?xml version="1.0" encoding="UTF-8"?>
SELECT * FROM users WHERE id = #{id}
</select>
<insert id="insertUser">
INSERT INTO users(name, age) VALUES(#{name}, #{age})
</insert>
<update id="updateUser">
UPDATE users SET name = #{name}, age = #{age} WHERE id = #{id}
</update>
<delete id="deleteUser">
DELETE FROM users WHERE id = #{id}
</delete>
</mapper>
第六步:编写测试代码
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 java.io.IOException;
import java.io.InputStream;
public class Main
public static void main(String[] args) throws IOException // 加载MyBatis配置文件
String resource = "mybatis-config.xml";
InputStreamis = Resources.getResourceAsStream(resource);
// 创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder(.build(is);
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession(;
// 获取Mapper对象
UserMapper userMapper =
sqlSession.getMapper(UserMapper.class);
// 调用Mapper方法进行数据操作
User user = userMapper.getUserById(1);
System.out.println(user);
User newUser = new User(;
newUser.setName("John");
newUser.setAge(25);
userMapper.insertUser(newUser);
newUser.setAge(30);
userMapper.updateUser(newUser);
userMapper.deleteUser(1);
//提交事务
//关闭资源
sqlSession.close(;
}
最后,运行Main类,即可完成对数据库的基本操作。

相关文档
最新文档