Mybatis(一）

最新推荐文章于 2022-07-22 10:31:44 发布

好好学java的xz

最新推荐文章于 2022-07-22 10:31:44 发布

阅读量642

点赞数

文章标签： mybatis

本文链接：https://blog.csdn.net/m0_51945098/article/details/121574681

版权

原因：
servlet + jsp + db 性能低下
所以就有了 spring + mybatis + springmvc

1.为什么使用框架技术？

通过框架来制定开发规范，
更进一步保证所有开发人员能够快速编写出统一的代码,
让开发人员专注于业务实现。

2.常用框架技术？（SSM）
SSJ 》 spring + springmvc + jdbc
SSH 》spring + structs2 + hibernate
SSM 》spring + springmvc+ mybatis

ssm 最常用 ssh不常用，几乎没了 ssj不用

2.1 Spring

Spring是一个J2EE的框架，这个框架提供了对轻量级IOC的良好支持，
同时也提供了对AOP技术非常好的封装，相比于其他的框架，
Spring框架的设计更加模块化，框架内的每个模块都能完成特定的工作，
而且各个模块可以独立的运行，不会相互的前置，
因此，在使用Spring框架的时候，我们可以使用整个框架，
也可以使用框架中的一部分。

spring是粘合剂把 springmvc和mybatis产生联系

注意：
1.IOC》控制反转（依赖注入）》一种设计思想
IOC理论提出的观点大体是这样的：
借助于“第三方”实现具有依赖关系的对象之间的解耦。

2.AOP （面向切面编程）

AspectJ 框架最牛逼的框架专门的人做专门的事

2.2 SpringMVC 前端和后端组合起来

Spring MVC是一个基于Java的实现了MVC设计模式
的请求驱动类型的轻量级Web框架，
通过把Model，View，Controller分离，
将web层进行职责解耦，
把复杂的web应用分成逻辑清晰的几部分，
简化开发，减少出错，方便组内开发人员之间的配合。

2.3 Mybatis （封装jdbc的作用）

Mybatis是一个半ORM（对象关系映射）框架，
它内部封装了JDBC，开发时只需要关注SQL语句本身，
不需要花费精力
去处理加载驱动、创建连接、创建statement等繁杂的过程。
程序员直接编写原生态sql，
可以严格控制sql执行性能，灵活度高。

==> ORM对象关系映射:
用于实现面向对象编程语言里不同类型系统的数据之间的转换。
简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，
将程序中的对象与关系数据库相互映射。

3.Mybatis框架

实体类和表中间的那个ORM

3.1Mybatis背景

MyBatis前身是iBatis，本是Apache的一个开源的项目

3.2Mybatis拓展

ORM框架,(只要提供了持久化类与表的映射关系，
ORM框架在运行时就能参照映射文件的信息，把对象持久化到数据库中)

3.3Mybatis特点

1.基于SQL语法，简单易学
2.SQL语句封装在配置文件中，便于统一管理与维护，降低程序的耦合度

3.4Mybatis组成部分

(1)核心对象

SqlSessionFactoryBuilder:
MyBatis应用的核心: SqlSessionFactory
SqlSession ==》执行sql语句

通过第一个创建第二个，第二个创建第三个，但我们只用第三个。
在这里插入图片描述
(2)核心配置文件（实体类映射表的）
mybatis-config.xml

<environments default="development">  		//默认的运行环境 ID
<environment id="development">				//运行环境 ID
<transactionManager type="JDBC"/>			//事务管理器配置
<dataSource type="POOLED">					//数据源配置
    <property name="driver" value="${driver}"/>
	<property name="url" value="${url}"/>
	<property name="user" value="${username}"/>	
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>

(3)sql映射文件映射实体类和我们的数据类表的

<mapper namespace="cn.dao.UserMapper">
	<select id="count" resultType="java.lang.Integer">
		select count(1) from user
	</select>
</mapper>

4.mybatis实战

1.数据库/表t_person

2.创建工程
main/java,main/resources,test/java

3.加入依赖pom.xml

<dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.21</version>
</dependency>

3.创建实体类Person.java
cn.kgc.entity/Person

package cn.kgc.entity;

public class Person {
    private Integer id;
    private String name;
    private String nickname;
    private Integer age;
//省略getter和setter方法
}

4.创建mapper接口(即dao接口)
cn.kgc.mapper/PersonMapper.java

package cn.kgc.mapper;

import cn.kgc.entity.Person;

//xml名字和这个一模一样，xml才能映射过来
public interface PersonMapper {
    //定义查询记录数方法
    Integer findCount();
    //增加功能
    Integer addPerson(Person person);
    //修改功能
    Integer updatePerson(Person person);
    //删除功能
    Integer delById(Integer id);
    //通过id查询对象
    Person findById(Integer id);
	//查询所有
   List<Person> findAll();
   //模糊查询
   List<Person> findByName(String name);
	//通过用户名和昵称 绝对查询
   List<Person> findByPerson(Person person);
   //通过用户名和昵称 绝对查询2
   List<Person> findByPerson2(@Param("name") String name,@Param("nickname") String nickname);
}

注意点：
==>绝对查询2
这里是根据注解来替换的，
并且在PersonMapper.xml不用写parameterType

@Param注解的使用和解析（摘录）
作用： 用注解来简化xml配置的时候
（比如Mybatis的Mapper.xml中的sql参数引入），
@Param注解的作用是给参数命名,
参数命名后就能根据名字得到参数值,正确的将参数传入sql语句中
（一般通过#{}的方式，${}会有sql注入的问题）。

5.创建mybatis映射文件

resources/cn.kgc.mapper/PersonMapper.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="cn.kgc.mapper.PersonMapper">
<!--    namespace 必须要与接口的地址一样  生成Mapper的实现类Mybatis底层帮我们实现了-->
    <select id="findCount" resultType="java.lang.Integer">
-- id与接口中的方法名称保持一致  没有体现类 已经帮你封装了 但sql语句还是要写的 resultType和接口方法返回值包（全）路径保持一致 才能映射 也可以写成int或integer 也可以不写 建议写全
        select count(*) from t_person
    </select>

    <insert id="addPerson" parameterType="cn.kgc.entity.Person">
-- 增删改不用写返回值 resultType    查询需要
        insert into t_person(`name`,nickname,age) values(#{name},#{nickname},#{age})
    </insert>

    <update id="updatePerson" parameterType="cn.kgc.entity.Person">
        update t_person set name = #{name},nickname = #{nickname},age = #{age} where id = #{id}
    </update>

    <delete id="delById" parameterType="java.lang.Integer">
        delete from t_person where id = #{id}
    </delete>

    <select id="findById"  parameterType="java.lang.Integer" resultType="cn.kgc.entity.Person">
        select * from t_person where id = #{id}
    </select>
<select id="findAll" resultType="cn.kgc.entity.Person">
      select * from t_person
  </select>

  <select id="findByName" resultType="cn.kgc.entity.Person" parameterType="java.lang.String">
      select * from t_person where `name` like concat('%',#{name},'%')
  </select>
<select id="findByPerson2" resultType="cn.kgc.entity.Person">
      select * from t_person where  `name` = #{name} and nickname = #{nickname}
  </select>
 </mapper>

6.创建mybatis主配置文件

resources/ mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
        "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
<!—如果报红 idea没有识别，所以alt  回车 设置下-->
<!--根文件 节点-->
<configuration>
<settings>
        	<setting name="logImpl" value="STDOUT_LOGGING"/>
    	</settings>
<!--    settings在上面 有顺序-->
    <!--环境配置：数据库的连接信息-->
    <!--default：中配置的值需要和某个environment配置的id相同，
        通知mybatis使用具体哪一个数据库的连接信息，即具体访问对应的数据库-->
    <environments default="development">
    <!--environment:一个数据库信息的配置，环境-->
        <!--id属性：一个唯一值，自定义，表示环境的名称-->
        <environment id="development">
            <!--transactionManager属性：mybatis的事务类型-->
            <transactionManager type="JDBC" />
<!--跟数据库mysql交互的-->
            <!--dataSoure属性：代表数据源，连接数据库-->
            <!--type属性:JDBC 表示使用的是使用连接池的数据源-->
            <dataSource type="POOLED">
                <!--配置驱动-->
                <property name="driver" value=" com.mysql.cj.jdbc.Driver"/>
                <!--配置连接数据库的url字符串-->
                <property name="url" value=" jdbc:mysql://localhost:3306/db_mb001?characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC&amp;rewriteBatchedStatements=true"/>
                <!--配置连接数据库的用户名-->
                <property name="username" value="root"/>
                <!--配置连接数据库的密码-->
                <property name="password" value=" zjj"/>
            </dataSource>
        </environment>
    </environments>
	<!--sql映射文件标签-->
<!--    下面的mappers 映射到PersonMapper.xml 和数据库-->
    <mappers>
        <!--reource：从类路径开始的路径信息：target/clasess(类路径)-->
        <mapper resource="cn/kgc/mapper/PersonMapper.xml"/>
    </mappers>
</configuration>

dataSource的类型可以配置成其内置类型之一，
如UNPOOLED、POOLED、JNDI。

7.测试类TestMybatis.java
test/cn.kgc.test/ TestMybatis.java

package cn.kgc.test;

import cn.kgc.entity.Person;
import cn.kgc.mapper.PersonMapper;
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 java.io.IOException;
import java.io.InputStream;

public class TestMybatis {
    @Test
    public void testHelloWorld() throws IOException {
        //1.定义配置文件
        String config = "mybatis-config.xml";
        //2.读取配置文件  ==》通过流的机制获取主配置文件mybatis -config . xml的主配置信息
        InputStream in = Resources.getResourceAsStream(config);
        //3.创建（实例化）SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //4.调用builder对象的build ()方法创建SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(in);
        //5.调用factory对象的openSession()方法 获取sqlSession对象
        SqlSession sqlSession = factory.openSession();
        //6. 调用接口方法      执行sql语句
        Integer count = sqlSession.getMapper(PersonMapper.class).findCount();
        //输出对应的返回值count
        System.out.println("count:"+count);
        //7.关闭sqlSession对象
        sqlSession.close();
    }
    @Test
    public void testInsert() throws Exception{
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession sqlSession = factory.openSession();
        //调用 接口 方法
        Person p = new Person();
        p.setName("张三");
        p.setAge(35);
        p.setNickname("小张啊");
        sqlSession.getMapper(PersonMapper.class).addPerson(p);
//        默认是不提交给数据库 需要手动加  增删改
        //如果不写 数据库没添加 但id自增长 id就自动多加一位了
        sqlSession.commit();//提交事务，该行代码务必放在关闭sqlSession之前
        sqlSession.close();
    }
    @Test
    public void testUpdate() throws Exception{
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession sqlSession = factory.openSession();
        Person p = new Person();
        p.setId(5);
        p.setName("小蓝");
        p.setNickname("兰兰");
        p.setAge(19);
        sqlSession.getMapper(PersonMapper.class).updatePerson(p);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void testDel() throws Exception {
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession sqlSession = factory.openSession();
        sqlSession.getMapper(PersonMapper.class).delById(5);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void testFindById() throws Exception {
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession sqlSession = factory.openSession();
        Person p = sqlSession.getMapper(PersonMapper.class).findById(7);
        System.out.println("id:" + p.getId() + "    name:" + p.getName() + "    nickname:" + p.getNickname() +"    age:" + p.getAge());
        sqlSession.close();
    }
@Test
public void testFindAll() throws Exception {
    InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = builder.build(in);
    SqlSession sqlSession = factory.openSession();
    List<Person> list = sqlSession.getMapper(PersonMapper.class).findAll();
    for (Person p : list) {
        System.out.println("name:" + p.getName() + "\t" +"nickname:" + p.getNickname() + "\t" +"age:" + p.getAge());
    }
    sqlSession.close();
}
  @Test
public void testFindByName() throws Exception {
    InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = builder.build(in);
    SqlSession sqlSession = factory.openSession();

    List<Person> list = sqlSession.getMapper(PersonMapper.class).findByName("x");
    for (Person p : list) {
        System.out.println("name:" + p.getName() + "\t" +"nickname:" + p.getNickname() + "\t" +"age:" + p.getAge());
    }
    sqlSession.close();
}
	@Test
    public void testFindByPerson2() throws Exception {
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession sqlSession = factory.openSession();
        List<Person> list = sqlSession.getMapper(PersonMapper.class).findByPerson2("wangwu","ww");
        for (Person p :
                list) {
            System.out.println("name:" + p.getName() + "\t" +"nickname:" + p.getNickname() + "\t" +"age:" + p.getAge());
        }
        sqlSession.close();
    }
}

//<==      Total: 1   1个返回值

sqlSession.commit();//增删改必须要加

注意点：
如果报错了，可能是文件夹的问题

<mappers>
    <mapper resource="cn/kgc/mapper/PersonMapper.xml" />
</mappers>

记得一个一个创建文件夹。先cn 再kgc再mapper

8.测试
附注：
工程目录结构在这里插入图片描述
注意： 加入日志mybatis-config.xml

<!--setttings:控制mybatis全局配置行为-->
    <settings>
        <!--设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

logImpl 指定MyBatis所用日志的具体实现,未指定时将自动查找。
STDOUT_LOGGING是标准日志。mybatis自带的

testFindByPerson2()==》
在这里插入图片描述
10.测试

升级版，上面的太冗余，下面相当于是优化

11.工具类: cn.kgc.util/MybatisUtil.java

package cn.kgc.util;

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 MyBatisUtil {
    private static SqlSessionFactory factory = null;
    static {
        try {
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            factory = builder.build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //    获取SqlSession
    public static SqlSession getSqlSession(){
        SqlSession sqlSession = null;
        if (factory != null){
            sqlSession = factory.openSession();
        }
        return sqlSession;
    }
}

12.测试cn.kgc.test/TestMybatis2.java
》针对于Integer findCount();

@Test
public void testFindCount(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    Integer count = sqlSession.getMapper(PersonMapper.class).findCount();
    System.out.println(count);
}

13.#和$不同应用场景（面试题很重要）

#：占位符语法：替换值

$: 字符串替换语法: 替换表名/列名/不同列排序等

$ 不安全： Statement 不能防止sql注入
# 安全： PreparedStatement 可以防止sql注入

A.PersonMapper.java

public List<Person> findColList(@Param("colName") String colName);

B.PersonMapper.xml

<select id="findColList" resultType="cn.kgc.entity.Person">
        select * from t_person order by ${colName}
</select>

C.TestMybatis

    @Test
public void testFindColList(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    List<Person> age = sqlSession.getMapper(PersonMapper.class).findColList("age");
    for (Person p : age) {
        System.out.println("name:" + p.getName() + "\t" +"nickname:" + p.getNickname() + "\t" +"age:" + p.getAge());
    }
    sqlSession.close();
}

结果就是根据age升序排序。

再次优化：

14.使用配置文件

A,resources/jdbc.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db_mb001?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true
username=root
password=zjj

B,mybatis-config.xml

。。。省略
<configuration>
    <properties resource="jdbc.properties" />
… (settings标签上面)
<environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
<!--            跟数据库mysql交互的-->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
。。。mappers标签
</configuration>

附注：
在这里插入图片描述
题外话：
1.如何使用Lombok

pom.xml里导入Lombok依赖

<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.20</version>
  <scope>provided</scope>
</dependency>

用处就是可以不用打getter和setter方法
不用打有参和无参方法和toString方法等等

import lombok.*;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class User {
    private String name;
    private String pwd;
}

2.有下面依赖就可以在resources里创建
spring-config.xml

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.3.12</version>
</dependency>

XML Configuration File -> Spring Config

3.什么是mybatis?(面试题)
一种持久层框架，类似于JDBC访问数据库的操作，
我们说JDBC使用到的对象有Connection对象，
PreparedStatement对象， ResultSet对象。
而Mybatis框架的核心对象有SqISessionFactoryBuilder对象，
SqISessionFactory对象， SqlSession对象。
并且myibatis框架和hibernate框架最大的区别
就在于mybatis它的灵活性比较高。

4.什么是spring?(面试题)
1.在spring出来之前，service层调用dao层都是用new的方式。

2.在Sspring出来之后，service层和dao层都会放在spring容器去管理，
这是spring的第一种特性,我们称之为IOC,控制反转。

3.spring还有一种特性，我们称之为AOP,大白话，“面向切面”，
说白了就是专门的人干专门的事。在项目很多公有的或是
要被重复被调用的模块可以被抽取出来，
利用的就是AOP的特性，例如日志模块。

----2021.11.25&11.26&11.27

好好学java的xz

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis(一）

原因：servlet + jsp + db 性能低下所以就有了 spring + mybatis + springmvc1.为什么使用框架技术？通过框架来制定开发规范，更进一步保证所有开发人员能够快速编写出统一的代码,让开发人员专注于业务实现。2.常用框架技术？（SSM）SSJ 》 spring + springmvc + jdbcSSH 》spring + structs2 + hibernateSSM 》spring + springmvc+ mybatisssm 最常用 ss
复制链接

扫一扫