MyBatis基础-01

最新推荐文章于 2023-08-02 18:51:21 发布

清晨的第一抹阳光a

最新推荐文章于 2023-08-02 18:51:21 发布

阅读量107

点赞数

本文链接：https://blog.csdn.net/qq_39354297/article/details/106991479

版权

MyBatis简介

1、MyBatis；和数据库进行交互；持久化层框架（SQL映射框架）；

1）、从原始的JDBC----dbutils(QueryRunner)-------JdbcTemplate----xxx；不用的

称为工具；

工具：一些功能的简单封装

框架：某个领域的整体解决方案；缓存，考虑异常处理问题，考虑部分字段映射问题。。。

不用原生JDBC：

1）、麻烦；

2）、sql语句是硬编码在程序中的；耦合（数据库层的和java编码耦合）；

2）、Hibernate-数据库交互的框架（ORM框架）（使用各种框架，全自动的框架）

ORM（Object Relation Mapping）对象关系映射；

创建好javaBean；

@Table("t_employee")

class Employee{

private Integer empId;

private String empName;

}

session.get("1"，Employe.class);

缺点：

1）、定制sql；

2）、HQL；SQL；

3）、全映射框架；部分字段映射很难；能做；

希望：最好有一个框架能支持定制化sql，而且还功能强大；sql也不要硬编码在java文件中（导致维护修改起来比较麻烦）；

1）、MyBatis将重要的步骤抽取出来可以人工定制，其他步骤自动化；

2）、重要步骤都是写在配置文件中（好维护）；

3）、完全解决数据库的优化问题；

4）、MyBatis底层就是对原生JDBC的一个简单封装；

5）、既将java编码与sql抽取了出来，还不会失去自动化功能；半自动的持久化层框架；

6）、mybatis是一个轻量级的框架；

代码示例：

Employee.java:

 1 package com.atguigu.bean;
 2 
 3 public class Employee {
 4     
 5     private Integer id;
 6     private String empName;
 7     private String email;
 8     private Integer gender;
 9 
10     
11     public Integer getId() {
12         return id;
13     }
14     public void setId(Integer id) {
15         this.id = id;
16     }
17     public String getEmpName() {
18         return empName;
19     }
20     public void setEmpName(String empName) {
21         this.empName = empName;
22     }
23     public String getEmail() {
24         return email;
25     }
26     public void setEmail(String email) {
27         this.email = email;
28     }
29     public Integer getGender() {
30         return gender;
31     }
32     public void setGender(Integer gender) {
33         this.gender = gender;
34     }
35     /* (non-Javadoc)
36      * @see java.lang.Object#toString()
37      */
38     @Override
39     public String toString() {
40         return "Employee [id=" + id + ", empName=" + empName + ", email="
41                 + email + ", gender=" + gender + "]";
42     }
43 
44 }

EmployeeDao.java:

 1 package com.atguigu.dao;
 2 
 3 import com.atguigu.bean.Employee;
 4 
 5 /**
 6  * @Title: EmployeeDao
 7  * @Description:
 8  * @Author:
 9  * @Version: 1.0
10  * @create 2020/6/25 11:11
11  */
12 public interface EmployeeDao {
13 
14     //按照员工id查询员工
15     public Employee getEmpById(Integer id);
16 
17 }

EmployeeDao.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper
 3   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 <!--namespace：名称空间；写接口的全类名，相当于告诉MyBatis这个配置文件是实现哪个接口的；  -->
 6 <mapper namespace="com.atguigu.dao.EmployeeDao">
 7 
 8 <!-- public Employee getEmpById(Integer id); -->
 9  <!-- 
10  select：用来定义一个查询操作   
11  id:方法名，相当于这个配置是对于某个方法的实现 
12 resultType:指定方法运行后的返回值类型；（查询操作必须指定的）
13  #{属性名}：代表取出传递过来的某个参数的值
14  -->
15  
16   <select id="getEmpById" resultType="com.atguigu.bean.Employee">
17     select * from t_employee where id=#{id}
18   </select>
19 </mapper>

mybatis-config.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE configuration
 3   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 <configuration>
 6     
 7   <environments default="development">
 8     <environment id="development">
 9       <transactionManager type="JDBC"/>
10       <!-- 配置连接池 -->
11       <dataSource type="POOLED">
12         <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
13         <property name="url" value="jdbc:mysql://localhost:3306/mybatis_0325?characterEncoding=utf-8&amp;serverTimezone=GMT%2B8"/>
14         <property name="username" value="root"/>
15         <property name="password" value="root"/>
16       </dataSource>
17     </environment>
18   </environments>
19   
20   
21   <!-- 引入我们自己编写的每一个接口的实现文件 -->
22   <mappers>
23       <!--resource:表示从类路径下找资源  -->
24     <mapper resource="mybatis/EmployeeDao.xml"/>
25   </mappers>
26 </configuration>

log4j.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
 3  
 4 <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
 5  
 6  <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
 7    <param name="Encoding" value="UTF-8" />
 8    <layout class="org.apache.log4j.PatternLayout">
 9     <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n" />
10    </layout>
11  </appender>
12  <logger name="java.sql">
13    <level value="debug" />
14  </logger>
15  <logger name="org.apache.ibatis">
16    <level value="info" />
17  </logger>
18  <root>
19    <level value="debug" />
20    <appender-ref ref="STDOUT" />
21  </root>
22 </log4j:configuration>

MyBatisTest.java:

 1 package com.atguigu.test;
 2 
 3 import com.atguigu.bean.Employee;
 4 import com.atguigu.dao.EmployeeDao;
 5 import org.apache.ibatis.io.Resources;
 6 import org.apache.ibatis.session.SqlSession;
 7 import org.apache.ibatis.session.SqlSessionFactory;
 8 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 9 import org.junit.Test;
10 
11 import java.io.IOException;
12 import java.io.InputStream;
13 
14 /**
15  * @Title: MyBatisTest
16  * @Description:
17  * @Author:
18  * @Version: 1.0
19  * @create 2020/6/25 14:01
20  */
21 public class MyBatisTest {
22 
23     @Test
24     public void test() throws IOException {
25         //1、根据全局配置文件创建出一个SqlSessionFactory
26         //SqlSessionFactory：是SqlSession工厂，负责创建SqlSession对象；
27         //SqlSession:sql会话（代表和数据库的一次会话）;
28         String resource = "mybatis-config.xml";
29         InputStream inputStream = Resources.getResourceAsStream(resource);
30         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
31 
32 
33         //4、调用之前的方法；
34         Employee employee;
35         SqlSession openSession = sqlSessionFactory.openSession();
36         try {
37             //2、获取和数据库的一次会话；getConnection()；
38             //3、使用SqlSession操作数据库，获取到dao接口的实现
39             EmployeeDao employeeDao = openSession.getMapper(EmployeeDao.class);
40             employee = employeeDao.getEmpById(1);
41         } finally{
42             openSession.close();
43         }
44         System.out.println(employee);
45     }
46 
47 }

初始化

MyBatis是持久化层框架（SQL映射框架）-操作数据库

1）、环境搭建

1）、创建一个java工程；

2）、创建测试库，测试表，以及封装数据的javaBean，和操作数据库的dao接口

创建表：自己用工具创建

创建javaBean：Employee（封装表的数据）

创建一个Dao接口，用来操作数据库；

3）、用MyBatis操作数据库？

1）、导包

//mysql-connector-java-5.1.37-bin.jar

//mybatis-3.4.1.jar

//log4j-1.2.17.jar

//建议导入日志包；这样的化在mybatis关键的环节就会有日志打印；

//log4j（日志框架）;依赖类路径下一个log4j.xml配置文件；

2）、写配置（两个，全局配置文件（指导mybatis运行的），dao接口的实现文件（描述dao中每个方法怎么工作））

1）、第一个配置文件；（称为mybatis的全局配置文件，指导mybatis如何正确运行，比如连接向哪个数据库）

2）、第二个配置文件：（编写每一个方法都如何向数据库发送sql语句，如何执行。。。。相当于接口的实现类）

1)、将mapper的namespace属性改为接口的全类名

2)、配置细节

<!--

select：用来定义一个查询操作

id:方法名，相当于这个配置是对于某个方法的实现

resultType:指定方法运行后的返回值类型；（查询操作必须指定的）

#{属性名}：代表取出传递过来的某个参数的值

-->

select * from t_employee where id=#{id}

</select>

</mapper>

3）、我们写的dao接口的实现文件，mybatis默认是不知道的，需要在全局配置文件中注册；

</mappers>

3）、测试

1）、根据全局配置文件先创建一个

String resource = "mybatis-config.xml";

InputStream inputStream = Resources.getResourceAsStream(resource);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

2）、sqlSessionFactory中获取sqlSession对象操作数据库即可

//2、获取和数据库的一次会话；getConnection()；

SqlSession openSession = sqlSessionFactory.openSession();

//3、使用SqlSession操作数据库，获取到dao接口的实现

EmployeeDao employeeDao = openSession.getMapper(EmployeeDao.class);

//4、调用之前的方法；

Employee employee = employeeDao.getEmpById(1);

System.out.println(employee);

如何写xml有提示；

1）、只要eclipse找到了这个文件的dtd约束文件的位置即可

2）、绑定约束文件的位置

1、复制dtd的引用网址：

http://mybatis.org/dtd/mybatis-3-config.dtd

2、window-perferences

两个文件：

1）、全局配置文件：mybatis-config.xml；指导mybatis正确运行的一些全局设置；

2）、SQL映射文件：EmployeeDao.xml；相当于是对Dao接口的一个实现描述

细节：

1）、获取到的是接口的代理对象；mybatis自动创建的；

2）、SqlSessionFactory和SqlSession；

SqlSessionFactory创建SqlSession对象，Factory只new一次就行

SqlSession：相当于connection和数据库进行交互的，和数据库的一次会话，就应该创建一个新的sqlSession；

代码示例：

Employee.java:

 1 package com.atguigu.bean;
 2 
 3 import org.apache.ibatis.type.Alias;
 4 
 5 //批量起别名后自定义别名，不区分大小写
 6 @Alias("emp2")
 7 public class Employee {
 8 
 9     private Integer id;
10     private String empName;
11     private String email;
12     private Integer gender;
13     private String loginAccount;
14 
15     public Employee() {
16     }
17 
18     public Employee(Integer id, String empName, String email, Integer gender) {
19         this.id = id;
20         this.empName = empName;
21         this.email = email;
22         this.gender = gender;
23     }
24 
25     public Integer getId() {
26         return id;
27     }
28     public void setId(Integer id) {
29         this.id = id;
30     }
31     public String getEmpName() {
32         return empName;
33     }
34     public void setEmpName(String empName) {
35         this.empName = empName;
36     }
37     public String getEmail() {
38         return email;
39     }
40     public void setEmail(String email) {
41         this.email = email;
42     }
43     public Integer getGender() {
44         return gender;
45     }
46     public void setGender(Integer gender) {
47         this.gender = gender;
48     }
49     public String getLoginAccount() {
50         return loginAccount;
51     }
52 
53     public void setLoginAccount(String loginAccount) {
54         this.loginAccount = loginAccount;
55     }
56     /* (non-Javadoc)
57      * @see java.lang.Object#toString()
58      */
59 
60     @Override
61     public String toString() {
62         return "Employee{" +
63                 "id=" + id +
64                 ", empName='" + empName + '\'' +
65                 ", email='" + email + '\'' +
66                 ", gender=" + gender +
67                 ", loginAccount='" + loginAccount + '\'' +
68                 '}';
69     }
70 }

EmployeeDao.java:

 1 package com.atguigu.dao;
 2 
 3 import com.atguigu.bean.Employee;
 4 
 5 /**
 6  * @Title: EmployeeDao
 7  * @Description:
 8  * @Author:
 9  * @Version: 1.0
10  * @create 2020/6/25 11:11
11  */
12 public interface EmployeeDao {
13 
14     public Employee getEmpById(Integer id);
15     public int updateEmployee(Employee employee);
16     public boolean deleteEmployee (Integer id);
17     public int insertEmployee(Employee employee);
18 
19 }

EmployeeDaoAnnotation.java:

 1 package com.atguigu.dao;
 2 
 3 import com.atguigu.bean.Employee;
 4 import org.apache.ibatis.annotations.Delete;
 5 import org.apache.ibatis.annotations.Insert;
 6 import org.apache.ibatis.annotations.Select;
 7 import org.apache.ibatis.annotations.Update;
 8 
 9 /**
10  * @Title: EmployeeDaoAnnotation
11  * @Description:
12  * @Author:
13  * @Version: 1.0
14  * @create 2020/6/26 10:18
15  */
16 public interface EmployeeDaoAnnotation {
17 
18     @Select("select * from t_employee where id=#{id}")
19     public Employee getEmpById(Integer id);
20 
21     @Update("UPDATE t_employee SET empname=#{empName},gender=#{gender},email=#{email} WHERE id=#{id}")
22     public int updateEmployee(Employee employee);
23 
24     @Delete("DELETE FROM t_employee WHERE id= #{id}")
25     public boolean deleteEmployee (Integer id);
26 
27     @Insert("INSERT INTO t_employee(empname,gender,email) VALUES(#{empName},#{gender},#{email})")
28     public int insertEmployee(Employee employee);
29 }

EmployeeDao.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper
 3         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 <!--namespace：名称空间；写接口的全类名，相当于告诉MyBatis这个配置文件是实现哪个接口的；  -->
 6 <!--默认这个查询是不区分环境的-->
 7 <mapper namespace="com.atguigu.dao.EmployeeDao">
 8 
 9     <!-- public Employee getEmpById(Integer id); -->
10     <!--
11     select：用来定义一个查询操作
12     id:方法名，相当于这个配置是对于某个方法的实现
13     resultType:指定方法运行后的返回值类型；（查询操作必须指定的）
14     #{属性名}：代表取出传递过来的某个参数的值
15     -->
16 
17     <!--
18 parameterType：参数类型不用写
19         sql不要写分号
20     -->
21     <!--<select id="getEmpById" resultType="Emp">-->
22     <!--<select id="getEmpById" resultType="EmployeE">-->
23     <select id="getEmpById" resultType="eMp2">
24         select * from t_employee where id=#{id}
25     </select>
26 
27     <!--如果能精确匹配就精确，不能就用模糊的-->
28     <!--<select id="getEmpById" resultType="eMp2" databaseId="mysql">
29         select * from t_employee where id=#{id}
30     </select>
31 
32     <select id="getEmpById" resultType="eMp2" databaseId="oracle">
33         select * from t_employee where id=#{id}
34     </select>-->
35 
36     <!--
37 增删不用写返回值类型，增删改是返回影响多少行
38         mybatis自动判断，如果是数字（int,long）
39         如果是boolean（影响0行自动封装false，否则true）
40         #{属性名}：从传入的参数对象中取出对应属性的值
41     -->
42     <update id="updateEmployee">
43         UPDATE t_employee SET empname=#{empName},gender=#{gender},email=#{email} WHERE id=#{id}
44     </update>
45 
46     <delete id="deleteEmployee">
47         DELETE FROM t_employee WHERE id= #{id}
48     </delete>
49 
50     <insert id="insertEmployee">
51         INSERT INTO t_employee(empname,gender,email) VALUES(#{empName},#{gender},#{email})
52     </insert>
53 
54 
55 </mapper>

dbconfig.properties:

1 username=root
2 password=root
3 jdbcUrl=jdbc:mysql://localhost:3306/mybatis_0325?characterEncoding=utf-8&serverTimezone=GMT%2B8
4 driverClass=com.mysql.cj.jdbc.Driver

mybatis-config.xml:

  1 <?xml version="1.0" encoding="UTF-8" ?>
  2 <!DOCTYPE configuration
  3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5 <configuration>
  6     <!--每个标签的使用是有先后顺序的-->
  7     <!--1.和Spring的context:property-placeholder 引用外部配置文件-->
  8     <!--
  9 resource：从类路径下开始引用
 10 url：引用磁盘路径或者网络路径
 11     -->
 12     <properties resource="dbconfig.properties"></properties>
 13 
 14     <!--2.settings：这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。下表描述了设置中各项的意图、默认值等-->
 15     <settings>
 16         <!--驼峰命名    name：配置项的key，value：配置项的值-->
 17         <setting name="mapUnderscoreToCamelCase" value="true"/>
 18     </settings>
 19 
 20     <!--3.类型别名，为常用的类型（javaBean）起别名-->
 21     <typeAliases>
 22         <!--typeAlias:就是为一个javaBean起别名，别名默认就是类名，不区分大小写，配置文件中就可以用别名了-->
 23         <!--alias="emp"：指定一个别名，不区分大小写-->
 24         <!--<typeAlias type="com.atguigu.bean.Employee" alias="emp"></typeAlias>-->
 25 
 26         <!--批量起别名   name：指定包名，默认别名就是类名，不区分大小写-->
 27         <packagename="com.atguigu.bean"/>
 28         <!--推荐使用全类名-->
 29     </typeAliases>
 30 
 31     <!--4.类型处理器-->
 32     <!--<typeHandlers>
 33         &lt;!&ndash;自定义好的类型处理器就这么配置就好了&ndash;&gt;
 34         <typeHandler handler=""></typeHandler>
 35     </typeHandlers>-->
 36 
 37     <!--5.插件是mybatis的一个强大功能-->
 38 
 39     <!--6.environments配置环境
 40         environment：配置一个具体的环境，都需要一个事务管理器和一个数据源
 41             transactionManager：
 42         后来数据源和事务管理都是spring来做
 43     -->
 44     <!--default="development"默认使用哪个环境-->
 45     <environments default="development">
 46         <!--id="testEnv"是当前环境的唯一标识-->
 47         <environment id="testEnv">
 48             <transactionManager type="JDBC"/>
 49             <!-- 配置连接池 -->
 50             <dataSource type="POOLED">
 51                 <!--${}取出配置文件中的值-->
 52                 <property name="driver" value="${driverClass}"/>
 53                 <property name="url" value="jdbc:mysql://192.168.0.1:3306/mybatis_0325?characterEncoding=utf-8&amp;serverTimezone=GMT%2B8"/>
 54                 <property name="username" value="${username}"/>
 55                 <property name="password" value="${password}"/>
 56             </dataSource>
 57         </environment>
 58 
 59         <environment id="development">
 60             <transactionManager type="JDBC"/>
 61             <!-- 配置连接池 -->
 62             <dataSource type="POOLED">
 63                 <!--${}取出配置文件中的值-->
 64                 <property name="driver" value="${driverClass}"/>
 65                 <property name="url" value="${jdbcUrl}"/>
 66                 <property name="username" value="${username}"/>
 67                 <property name="password" value="${password}"/>
 68             </dataSource>
 69         </environment>
 70     </environments>
 71 
 72     <!--7.mybatis用来考虑数据库移植性的-->
 73     <databaseIdProvider type="DB_VENDOR">
 74         <!--name：数据库厂商标识    value：给这个标识起一个好用的名字
 75             MySQL、Oracle、SQL Server
 76         -->
 77         <property name="MySQL" value="mysql"/>
 78         <property name="Oracle" value="orcl"/>
 79         <property name="SQL Server" value="sqlserver"/>
 80     </databaseIdProvider>
 81 
 82     <!-- 引入我们自己编写的每一个接口的实现文件 -->
 83     <!--7.写好的sql映射文件需要使用mappers注册进来-->
 84     <mappers>
 85         <!--
 86             url：可以从磁盘或者网络路径引用
 87             class：直接引用接口的全类名
 88                 注意：可以将xml放在和dao接口同目录下，而且文件名和接口名一致
 89                 class的另一种用法
 90             resource：在类路径下找sql映射文件
 91         -->
 92         <!--<mapper class="com.atguigu.dao.EmployeeDao"></mapper>-->
 93         <!--class的另一种用法，注解版-->
 94         <!--<mapper class="com.atguigu.dao.EmployeeDaoAnnotation"></mapper>-->
 95         <!--<mapper resource="mybatis/EmployeeDao.xml"/>-->
 96         <!--配合使用：重要的dao可以写配置
 97             简单的dao就直接标注解
 98         -->
 99 
100         <!--批量注册-->
101         <!--name=""：dao所在的包名
102             xml配置文件要在同包下，也可在resources目录下创建com.atguigu.dao，编译后就会在一起
103         -->
104         <package name="com.atguigu.dao"/>
105     </mappers>
106 </configuration>

log4j.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
 3  
 4 <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
 5  
 6  <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
 7    <param name="Encoding" value="UTF-8" />
 8    <layout class="org.apache.log4j.PatternLayout">
 9     <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n" />
10    </layout>
11  </appender>
12  <logger name="java.sql">
13    <level value="debug" />
14  </logger>
15  <logger name="org.apache.ibatis">
16    <level value="info" />
17  </logger>
18  <root>
19    <level value="debug" />
20    <appender-ref ref="STDOUT" />
21  </root>
22 </log4j:configuration>

MyBatisCRUDTest.java:

 1 package com.atguigu.test;
 2 
 3 import com.atguigu.bean.Employee;
 4 import com.atguigu.dao.EmployeeDao;
 5 import com.atguigu.dao.EmployeeDaoAnnotation;
 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.Before;
11 import org.junit.Test;
12 
13 import java.io.IOException;
14 import java.io.InputStream;
15 
16 /**
17  * @Title: MyBatisCRUDTest
18  * @Description:
19  * @Author:
20  * @Version: 1.0
21  * @create 2020/6/25 21:35
22  */
23 public class MyBatisCRUDTest {
24 
25     SqlSessionFactory sqlSessionFactory;
26 
27     @Before
28     public void initSqlSessionFactory() throws IOException {
29         //1、根据全局配置文件创建出一个SqlSessionFactory对象
30         //SqlSessionFactory：是SqlSession工厂，负责创建SqlSession对象；
31         //SqlSession:sql会话（代表和数据库的一次会话）;
32         String resource = "mybatis-config.xml";
33         InputStream inputStream = Resources.getResourceAsStream(resource);
34         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
35     }
36 
37     /**
38      * @Description: 测试查询
39      * @Param: []
40      * @Return: void
41      * @Author:
42      * @Date: 2020/6/25 21:43
43      */
44     @Test
45     public void test() throws IOException {
46 
47         //2.得到SqlSession对象
48         SqlSession openSession = sqlSessionFactory.openSession();
49 
50         try {
51             //3.获取dao接口的实现（映射器）
52             EmployeeDao employeeDao = openSession.getMapper(EmployeeDao.class);
53 
54             Employee employee = employeeDao.getEmpById(1);
55             System.out.println(employee);
56 
57         } finally {
58             openSession.close();
59         }
60     }
61 
62     @Test
63     public void testInsert() {
64         //1.获取和数据库的一次会话
65         SqlSession openSession = sqlSessionFactory.openSession();
66 
67         try {
68             //2.获取接口的映射器
69             EmployeeDao mapper = openSession.getMapper(EmployeeDao.class);
70             //3.测试
71             int i = mapper.insertEmployee(new Employee(null, "tomcat", "tomcat@qq.com", 0));
72             System.out.println(i);
73         } finally {
74             //手动提交
75             openSession.commit();
76             openSession.close();
77         }
78 
79     }
80 
81     @Test
82     public void testAnnotation(){
83         //1.获取和数据库的一次会话
84         SqlSession openSession = sqlSessionFactory.openSession();
85 
86         try {
87             //2.获取接口的映射器
88             EmployeeDaoAnnotation mapper = openSession.getMapper(EmployeeDaoAnnotation.class);
89             //3.测试
90             Employee employee = mapper.getEmpById(1);
91             System.out.println(employee);
92         } finally {
93             openSession.close();
94         }
95     }
96 }

MyBatisCRUDTest.java:

 1 package com.atguigu.test;
 2 
 3 import com.atguigu.bean.Employee;
 4 import com.atguigu.dao.EmployeeDao;
 5 import com.atguigu.dao.EmployeeDaoAnnotation;
 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.Before;
11 import org.junit.Test;
12 
13 import java.io.IOException;
14 import java.io.InputStream;
15 
16 /**
17  * @Title: MyBatisCRUDTest
18  * @Description:
19  * @Author:
20  * @Version: 1.0
21  * @create 2020/6/25 21:35
22  */
23 public class MyBatisCRUDTest {
24 
25     SqlSessionFactory sqlSessionFactory;
26 
27     @Before
28     public void initSqlSessionFactory() throws IOException {
29         //1、根据全局配置文件创建出一个SqlSessionFactory对象
30         //SqlSessionFactory：是SqlSession工厂，负责创建SqlSession对象；
31         //SqlSession:sql会话（代表和数据库的一次会话）;
32         String resource = "mybatis-config.xml";
33         InputStream inputStream = Resources.getResourceAsStream(resource);
34         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
35     }
36 
37     /**
38      * @Description: 测试查询
39      * @Param: []
40      * @Return: void
41      * @Author:
42      * @Date: 2020/6/25 21:43
43      */
44     @Test
45     public void test() throws IOException {
46 
47         //2.得到SqlSession对象
48         SqlSession openSession = sqlSessionFactory.openSession();
49 
50         try {
51             //3.获取dao接口的实现（映射器）
52             EmployeeDao employeeDao = openSession.getMapper(EmployeeDao.class);
53 
54             Employee employee = employeeDao.getEmpById(1);
55             System.out.println(employee);
56 
57         } finally {
58             openSession.close();
59         }
60     }
61 
62     @Test
63     public void testInsert() {
64         //1.获取和数据库的一次会话
65         SqlSession openSession = sqlSessionFactory.openSession();
66 
67         try {
68             //2.获取接口的映射器
69             EmployeeDao mapper = openSession.getMapper(EmployeeDao.class);
70             //3.测试
71             int i = mapper.insertEmployee(new Employee(null, "tomcat", "tomcat@qq.com", 0));
72             System.out.println(i);
73         } finally {
74             //手动提交
75             openSession.commit();
76             openSession.close();
77         }
78 
79     }
80 
81     @Test
82     public void testAnnotation(){
83         //1.获取和数据库的一次会话
84         SqlSession openSession = sqlSessionFactory.openSession();
85 
86         try {
87             //2.获取接口的映射器
88             EmployeeDaoAnnotation mapper = openSession.getMapper(EmployeeDaoAnnotation.class);
89             //3.测试
90             Employee employee = mapper.getEmpById(1);
91             System.out.println(employee);
92         } finally {
93             openSession.close();
94         }
95     }
96 }

全局配置文件

<?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">

</dataSource>

</environment>

</environments>

</mappers>

</configuration>

全局配置文件；

configuration 配置

properties 属性
settings 设置
typeAliases 类型命名
typeHandlers 类型处理器
objectFactory 对象工厂，
plugins 插件，
environments 环境
- environment 环境变量
- - transactionManager 事务管理器
  - dataSource 数据源
databaseIdProvider 数据库厂商标识
mappers 映射器

原生jdbc执行sql；或者封装结果集

Connection connection = dataSource.getConnection();

String sql = "insert into t_employee(empname,email,gender) value(?,?,?)";

PreparedStatement ps = connection. prepareStatement(sql);

ps.setString(0,"admin");

ps.setString(1,"aaa@qq.com");

ps.setInt(2,12);

int i = ps. executeUpdate()

//ps.close();connection.close();

SQL映射文件

增删改标签

INSERT INTO t_employee(empname,gender,email)

VALUES(#{empName},#{gender},#{email})

</insert>

实现获取到插入数据后的自增id；

代码示例：

Employee.java:

 1 package com.atguigu.bean;
 2 
 3 import org.apache.ibatis.type.Alias;
 4 
 5 //批量起别名后自定义别名，不区分大小写
 6 //@Alias("emp2")
 7 public class Employee {
 8 
 9     private Integer id;
10     private String empName;
11     private String email;
12     private Integer gender;
13     private String loginAccount;
14 
15     public Employee() {
16     }
17 
18     public Employee(Integer id, String empName, String email, Integer gender) {
19         this.id = id;
20         this.empName = empName;
21         this.email = email;
22         this.gender = gender;
23     }
24 
25     public Integer getId() {
26         return id;
27     }
28     public void setId(Integer id) {
29         this.id = id;
30     }
31     public String getEmpName() {
32         return empName;
33     }
34     public void setEmpName(String empName) {
35         this.empName = empName;
36     }
37     public String getEmail() {
38         return email;
39     }
40     public void setEmail(String email) {
41         this.email = email;
42     }
43     public Integer getGender() {
44         return gender;
45     }
46     public void setGender(Integer gender) {
47         this.gender = gender;
48     }
49     public String getLoginAccount() {
50         return loginAccount;
51     }
52 
53     public void setLoginAccount(String loginAccount) {
54         this.loginAccount = loginAccount;
55     }
56     /* (non-Javadoc)
57      * @see java.lang.Object#toString()
58      */
59 
60     @Override
61     public String toString() {
62         return "Employee{" +
63                 "id=" + id +
64                 ", empName='" + empName + '\'' +
65                 ", email='" + email + '\'' +
66                 ", gender=" + gender +
67                 ", loginAccount='" + loginAccount + '\'' +
68                 '}';
69     }
70 }

EmployeeDao.java:

 1 package com.atguigu.dao;
 2 
 3 import com.atguigu.bean.Employee;
 4 import org.apache.ibatis.annotations.Param;
 5 
 6 import java.util.Map;
 7 
 8 /**
 9  * @Title: EmployeeDao
10  * @Description:
11  * @Author:
12  * @Version: 1.0
13  * @create 2020/6/25 11:11
14  */
15 public interface EmployeeDao {
16 
17     public Employee getEmpById(Integer id);
18     public Employee getEmpByIdAndEmpName(@Param("id") Integer id, @Param("empName") String empName);
19     public Employee getEmployeeByIdAndEmpName(Map<String,Object> map);
20     public int updateEmployee(Employee employee);
21     public boolean deleteEmployee (Integer id);
22     public int insertEmployee(Employee employee);
23     public int insertEmployee2(Employee employee);
24 
25 }

EmployeeDao.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper
 3         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 
 6 <mapper namespace="com.atguigu.dao.EmployeeDao">
 7     <!--namespace="com.atguigu.dao.EmployeeDao"写接口的全类名-->
 8     <!--这个文件中能写的所有标签
 9         cache
10         cache-ref
11         delete、update、insert、select
12         parameterMap：参数map，废弃的  原本是来做复杂参数映射的
13         resultMap：结果映射，自定义结果集的封装规则
14         sql：抽取可重用的sql
15 
16         databaseId：指定这个CRUD属于哪个数据库
17         parameterType：传入的参数类型，默认可不写，TypeHandler自动推断
18         statementType：默认PREPARED（安全）
19     -->
20 
21     <!--传参到底能传哪些-->
22     <select id="getEmpById" resultType="Employee">
23         select * from t_employee where id=#{id}
24     </select>
25 
26     <select id="getEmpByIdAndEmpName" resultType="Employee">
27         select * from t_employee where id=#{id} and empname=#{empName}
28     </select>
29 
30     <!--
31         现象：
32             1）单个参数：
33                基本类型：
34                     取值：#{随便写}
35 
36             2）多个参数：
37                取值：#{参数名}无效
38                可用：0,1（参数的索引）或者param1，param2（第几个参数paramN）
39                原因：只要传入了多个参数，mybatis会自动地将这些参数封装在一个map集合中，封装时使用的key就是参数的索引和参数的第几个标识
40                     Map<String,Object> map = new HashMap<>();
41                     map.put("1",传过来的值);
42                     map.put("2",传入的值);
43                     #{key}就是从这个map中取值
44 
45              3）@Param：为参数指定key：命名参数，推荐使用此方法
46                     使用指定的key
47 
48              4）传入pojo（javaBean）
49                 取值：#{pojo的属性名}
50 
51              5）传入map：将多个要使用的参数封装起来
52                 取值：#{key}
53 
54              扩展：多个参数自动封装map
55              method01(@Param("id")lnteger id,String empName,Employee employee);
56              Integer id ->#{id}
57              String empName ->#{param2}
58              Employee employee(取出这个里面jemail) ->#{param3.email}
59 
60              无论传入什么参数都要能正确地取出值
61              #{key/属性名}
62 
63     -->
64 
65     <select id="getEmployeeByIdAndEmpName" resultType="Employee">
66         select * from t_employee where id=#{id} and empname=#{empName}
67     </select>
68 
69     <update id="updateEmployee">
70         UPDATE t_employee SET empname=#{empName},gender=#{gender},email=#{email} WHERE id=#{id}
71     </update>
72 
73     <delete id="deleteEmployee">
74         DELETE FROM t_employee WHERE id= #{id}
75     </delete>
76 
77     <!--让mybatis自动地将自增id赋值给传入的employee对象的id属性
78         useGeneratedKeys="true"：原生jdbc获取自增主键的方法
79         keyProperty="id"：将刚才自增的id封装给哪个属性
80     -->
81 
82     <insert id="insertEmployee" useGeneratedKeys="true" keyProperty="id">
83         INSERT INTO t_employee(empname,gender,email) VALUES(#{empName},#{gender},#{email})
84     </insert>
85 
86     <insert id="insertEmployee2" useGeneratedKeys="true" keyProperty="id">
87         <!--
88             查询主键
89                 order="BEFORE"：
90                 在核心sql语句之前先运行一个查询sql查到id，将查到的id赋值给javaBean的那个属性
91         -->
92         <selectKey order="BEFORE" resultType="integer" keyProperty="id">
93             select max(id)+1 from t_employee
94         </selectKey>
95         INSERT INTO t_employee(id,empname,gender,email) VALUES(#{id},#{empName},#{gender},#{email})
96     </insert>
97 
98 </mapper>

dbconfig.properties:

1 username=root
2 password=root
3 jdbcUrl=jdbc:mysql://localhost:3306/mybatis_0325?characterEncoding=utf-8&serverTimezone=GMT%2B8
4 driverClass=com.mysql.cj.jdbc.Driver

log4j.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
 3  
 4 <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
 5  
 6  <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
 7    <param name="Encoding" value="UTF-8" />
 8    <layout class="org.apache.log4j.PatternLayout">
 9     <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n" />
10    </layout>
11  </appender>
12  <logger name="java.sql">
13    <level value="debug" />
14  </logger>
15  <logger name="org.apache.ibatis">
16    <level value="info" />
17  </logger>
18  <root>
19    <level value="debug" />
20    <appender-ref ref="STDOUT" />
21  </root>
22 </log4j:configuration>

mybatis-config.xml:

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE configuration
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 <configuration>
 6 
 7     <properties resource="dbconfig.properties"></properties>
 8 
 9     <settings>
10         <!--驼峰命名    name：配置项的key，value：配置项的值-->
11         <setting name="mapUnderscoreToCamelCase" value="true"/>
12     </settings>
13 
14     <typeAliases>
15         <!--批量起别名   name：指定包名，默认别名就是类名，不区分大小写-->
16         <package name="com.atguigu.bean"/>
17         <!--推荐使用全类名-->
18     </typeAliases>
19 
20 
21     <environments default="development">
22         <environment id="development">
23             <transactionManager type="JDBC"/>
24             <!-- 配置连接池 -->
25             <dataSource type="POOLED">
26                 <!--${}取出配置文件中的值-->
27                 <property name="driver" value="${driverClass}"/>
28                 <property name="url" value="${jdbcUrl}"/>
29                 <property name="username" value="${username}"/>
30                 <property name="password" value="${password}"/>
31             </dataSource>
32         </environment>
33     </environments>
34 
35 
36     <mappers>
37 
38         <mapper resource="mybatis/EmployeeDao.xml"/>
39 
40         <!--<package name="com.atguigu.dao"/>-->
41     </mappers>
42 </configuration>

MyBatisCRUDTest.java:

 1 package com.atguigu.test;
 2 
 3 import com.atguigu.bean.Employee;
 4 import com.atguigu.dao.EmployeeDao;
 5 import org.apache.ibatis.io.Resources;
 6 import org.apache.ibatis.session.SqlSession;
 7 import org.apache.ibatis.session.SqlSessionFactory;
 8 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 9 import org.junit.Before;
10 import org.junit.Test;
11 
12 import java.io.IOException;
13 import java.io.InputStream;
14 import java.util.HashMap;
15 import java.util.Map;
16 
17 /**
18  * @Title: MyBatisCRUDTest
19  * @Description:
20  * @Author:
21  * @Version: 1.0
22  * @create 2020/6/25 21:35
23  */
24 public class MyBatisCRUDTest {
25 
26     SqlSessionFactory sqlSessionFactory;
27 
28 @Before
29     public void initSqlSessionFactory() throws IOException {
30         //1、根据全局配置文件创建出一个SqlSessionFactory对象
31         //SqlSessionFactory：是SqlSession工厂，负责创建SqlSession对象；
32         //SqlSession:sql会话（代表和数据库的一次会话）;
33         String resource = "mybatis-config.xml";
34         InputStream inputStream = Resources.getResourceAsStream(resource);
35         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
36     }
37 
38     @Test
39     public void testInsert() {
40         //1.获取和数据库的一次会话
41         SqlSession openSession = sqlSessionFactory.openSession();
42 
43         try {
44             //2.获取接口的映射器
45             EmployeeDao mapper = openSession.getMapper(EmployeeDao.class);
46             Employee employee = new Employee(null, "tomcat2", "tomcat2@qq.com", 1);
47             //3.测试
48             //int i = mapper.insertEmployee(employee);
49             int j = mapper.insertEmployee2(employee);
50             //System.out.println("----->" + i);
51             // System.out.println("刚才插入的id：" + employee.getId());
52             openSession.commit();
53         } finally {
54             //手动提交
55 
56             openSession.close();
57         }
58 
59     }
60 
61     @Test
62     public void test2() {
63         SqlSession openSession = sqlSessionFactory.openSession();
64         try {
65             //2.获取接口的映射器
66             EmployeeDao employeeDao = openSession.getMapper(EmployeeDao.class);
67             Employee employee = employeeDao.getEmpByIdAndEmpName(1, "admin");
68             System.out.println(employee);
69 
70         } finally {
71             openSession.close();
72         }
73     }
74 
75 
76     @Test
77     public void test3() {
78         SqlSession openSession = sqlSessionFactory.openSession();
79         try {
80             //2.获取接口的映射器
81             EmployeeDao employeeDao = openSession.getMapper(EmployeeDao.class);
82             Map<String, Object> map = new HashMap<>();
83             map.put("id", 1);
84             map.put("empName", "admin");
85             Employee employee = employeeDao.getEmployeeByIdAndEmpName(map);
86             System.out.println(employee);
87 
88         } finally {
89             openSession.close();
90         }
91     }
92 
93 }

Employee

清晨的第一抹阳光a

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis基础-01

MyBatis简介1、MyBatis；和数据库进行交互；持久化层框架（SQL映射框架）；1）、从原始的JDBC----dbutils(QueryRunner)-------JdbcTemplate----xxx；不用的称为工具；工具：一些功能的简单封装框架：某个领域的整体解决方案；缓存，考虑异常处理问题，考虑部分字段映...
复制链接

扫一扫