MyBatis的简单使用与其入门案例

一.JDBC 

JDBC:java提供的一种规范，数据库厂商实现这种规范，在java中通过JDBC来操作数据库。

二.JDBC操作数据库

1.创建web工程，导入Maven

2.在pom文件中引入数据库的jar包

     <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
        <!--本地mysql的版本号-->
      <version>8.0.28</version>
    </dependency>

3.新建测试类，用jdbc查询表

1.具体代码

package com.hhh;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JdbcTest {
    public static void main(String[] args)throws Exception {
        //1.加载数据库驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

        //2.创建数据库连接  ssmframe为数据库名，后面跟着编码格式
        String url="jdbc:mysql://localhost:3306/ssmframe?characterEncoding=utf-8";
        String username="root";//用户名
        String password="hyt123456";//密码

        Connection connection = DriverManager.getConnection(url, username, password);
        //参数为sql语句
        PreparedStatement statement=connection.prepareStatement("select * from depart;");

        //这里的表depart搁mysql里头新建的

        //3.执行sql
       ResultSet resultSet= statement.executeQuery();

       //解析结果集
        while(resultSet.next()){
           String depid= resultSet.getString("depid");
           String dpname=resultSet.getString("depname");
           System.out.println("depid="+depid+",dpname="+dpname);
        }
    }
}

2.数据库表内容

 3.运行程序，查看结果

 4.JDBC操作数据库成功

4.将查询得到结果封装到一个类中

1.新建一个类Manager.java

package domain;

public class Manager {
    private String  id;
    private String name;

    public Manager(){
        
    }
    
    public Manager(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Manager{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

2.将从数据库中得到的数据封装

在JDBCTest类中添加对应代码

 3.执行程序，查看结果

 三.数据库连接池

数据库连接池：连接的缓存，就是这个连接用完可以回到池子里，下次再从池子里拿出来。

1.在pom文件导入连接池的依赖

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.0.9</version>
    </dependency>

2.改动JDBCTest代码中的连接

package com.hhh;

import com.alibaba.druid.pool.DruidPooledConnection;
import domain.Manager;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import com.alibaba.druid.pool.DruidDataSource;

public class JdbcTest {
    public static void main(String[] args)throws Exception {
        //1.加载数据库驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

        //2.创建数据库连接  ssmframe为数据库名
        String url="jdbc:mysql://localhost:3306/ssmframe?characterEncoding=utf-8";
        String username="root";//用户名
        String password="hyt123456";//密码

        //Connection connection = DriverManager.getConnection(url, username, password);
        //通过连接池获取连接,这里为测试所用，后面连接不配置在这
        DruidDataSource druidDataSource=new DruidDataSource();
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUrl(url);
        DruidPooledConnection connection = druidDataSource.getConnection();
        //参数为sql语句
        PreparedStatement statement=connection.prepareStatement("select * from depart;");


        //3.执行sql
       ResultSet resultSet= statement.executeQuery();

       //解析结果集
        while(resultSet.next()){
           String depid= resultSet.getString("depid");
           String dpname=resultSet.getString("depname");
           System.out.println("depid="+depid+",dpname="+dpname);

            //封装数据
            Manager manager=new Manager(depid,dpname);
            System.out.println(manager);
        }
    }
}

3.运行代码，查看效果

 四.MyBatis的入门案例

1.引入MyBatis依赖，刷新工程

   <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.2.8</version>
    </dependency>

2.数据库操作一般放在Dao层，这里新建Dao包，三层架构，每一层都有一个接口，这里新建接口，里面新建查询表的方法

package com.hhh.dao;

import domain.Manager;

public interface IsManagerDao {

    Manager findByid();
}

3.在resources下新建包，包内新建sql配置文件，在里面配置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">

<!-- namespace表示给哪个文件提供SQL-->
<mapper namespace="com.hhh.dao.IsManagerDao">
<!--查询语句 ， 这里的id和dao层接口的方法名一致，resultType为方法返回值的类型，不过填的是该类的具体路径-->
    <select id="findByid" resultType="domain.Manager">
        <!--写查询语句-->
        select * from depart;
    </select>
</mapper>

4.在resources目录下新建mybatis的配置文件，名为xx.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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
<!--数据库的连接池类型是POOLED-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssmframe?characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="hyt123456"/>
            </dataSource>
        </environment>
    </environments>
<!--    告诉mybatis去哪个路径下找SQL-->
    <mappers>
        <mapper resource="com/dao/IsManagerDao.xml"/>
    </mappers>
</configuration>

5.在java目录下新建测试类MyBatisTest01.java

package domain;

import com.hhh.dao.IsManagerDao;
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 MyBatisTest01 {
    public static void main(String[] args) throws IOException {
      // mybatis核心对象: sqlSessionFactory
        //1.加载MyBatis配置文件
        InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");

        //2.创建 sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(stream);

        //3.得到sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //4.得到dao接口的实现类
        IsManagerDao isManagerDao = sqlSession.getMapper(IsManagerDao.class);
        Manager manager = isManagerDao.findByid();

        System.out.println(manager);

    }
}

6.运行MyBatisTest01.java，查看效果

该数据表中只有一条数据，如果插入多条数据会报错误：

 Expected one result (or null) to be returned by selectOne(), but found: 7

所以这里删除depart表中的其他数据，只留存一条，没找着结果为什么为空，先过

 五.Mybatis的基本SQL标签，在sql的配置文件中测试各类标签

1.insert标签

<!--  新增数据，  插入标签-->
    <insert id="insert">
        insert into depart values(2,"营销部");
    </insert>

1.每个标签都需有dao层对应的方法，新增IsManagerDao.java中的方法

void insert();

2.新建一个测试类MyBatisTest02，用来测试插入语句

package domain;

import com.hhh.dao.IsManagerDao;
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 MyBatisTest02 {
    public static void main(String[] args) throws IOException {

        InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(stream);

        SqlSession sqlSession = sqlSessionFactory.openSession(true);//注意事务
        IsManagerDao isManagerDao = sqlSession.getMapper(IsManagerDao.class);
        isManagerDao.insert();

    }
}

3.运行程序，在数据库查询一下是否插入

 

 2.delete标签

<!--    删除数据，删除标签-->
    <delete id="delete">
        delete from depart where  depid=2;
    </delete>

1.每个标签都需有dao层对应的方法，新增IsManagerDao.java中的方法

  //删除方法
    void delete();

2.在 MyBatisTest02类中加入语句，注释插入语句

        isManagerDao.delete();

3.运行程序，在数据库运行环境内查看结果 

  3.update标签

<!--    更新标签-->
    <update id="update">
        update depart set depname="市场部" where depid=8;
    </update>
</mapper>

1.每个标签都需有dao层对应的方法，新增IsManagerDao.java中的方法

 2.在 MyBatisTest02类中加入语句，注释插入、删除语句

 3.运行程序，在数据库运行环境内查看结果 

六.mybatis的sql传参，这里新建了一个数据库表为manager1

数据库manager1 的内容,depart因为字段类型有点不对应，换表测试

 

1.简单类型的参数

1.在IsManagerDao接口中先给find方法加一个参数

   Manager findByid(String id);

2.在测试类MyBatisTest01中加上参数

 Manager manager=isManagerDao.findByid("2");

3.在sql的配置文件IsManagerDao.xml中接参数（形式：#{}）

    <select id="findByid" resultType="domain.Manager">
        <!--写查询语句-->
        select * from manager1 where id=#{id};
    </select>
<!--这里花括号里的id跟findByid方法中的参数名一致，where后面的id是数据库的字段名-->

4.运行，查看结果

  2.多个简单类型参数

1.在IsManagerDao接口中新建方法并加两个参数

多个参数的查询重点就在于注解@Param("xx")修饰方法参数

    //加注解@Param,参数名保持一致
    Manager findTwo(@Param("id") String id, @Param("name") String name);

2.在sql的配置文件IsManagerDao.xml添加一个select标签

注意：这里的id要与新建方法名一致

<!--多个参数查询-->
    <select id="findTwo" resultType="domain.Manager">
        <!--写查询语句-->
        select * from manager1 where id=#{id} and name=#{name};
    </select>

3.在MyBatisTest02类中添加查询语句

        Manager manager = isManagerDao.findTwo("1", "营销部");
        System.out.println(manager);

4.运行，查看结果

  3.一个复杂类型的参数

1.在IsManagerDao接口中用insert方法用来测试

    void insert(Manager manager);

2.在sql的配置文件IsManagerDao.xml的insert标签进行改动

    <insert id="insert">
        insert into manager1(id,name) values(#{id},#{name});
    </insert>

3.在MyBatisTest02类中添加对应语句

注意：前头所运用到的查询插入删除语句注释

        Manager manager=new Manager();
        manager.setName("aaa");
        manager.setId("3");
        isManagerDao.insert(manager);
        System.out.println(manager);

4.运行程序，查看效果

 4.多个复杂类型的参数

1.在IsManagerDao接口中新建方法并加两个参数

   //   多个参数
   //加注解@Param
   void insert2(@Param("manager1")Manager manager1,@Param("manager2")Manager manager2);

2.在sql的配置文件IsManagerDao.xml的新建insert标签进行配置

  <!--多个参数进行插入-->
    <insert id="insert2">
    <!--用第一个对象传id，用第二个对象传name-->
        insert into manager1(id,name) values(#{manager1.id},#{manager2.name});
    </insert>

3.在MyBatisTest02类中添加对应语句

        Manager manager=new Manager();
//      第一个对象只给参数id
        manager.setId("7");

        Manager manager2=new Manager();
//        第二个对象只给参数name
        manager2.setName("bbb");

        isManagerDao.insert2(manager,manager2);

4.运行程序，查看效果

5.#{}h和${}的区别

1）${}，会有sql注入，它是把参数原样拼在了SQL语句的后边

2）#{}，sql会预编译，不会改变sql的原有逻辑

1.测试${}

1.在isManagerDao类中新建一个方法

   Manager find(String id);

2.在IsManagerDao.xml中，新添select标签

这里参数使用&{}

    <select id="find" resultType="domain.Manager">
        <!--写查询语句-->
        select * from manager1 where id=${id};
    </select>

3.在MyBatisTest02类中添加对应语句

        Manager a = isManagerDao.find("7");
        System.out.println(a);

4.运行程序，查看效果

用${}传参数会报没有get、set方法

 5.需要在IsManagerDao类的find方法里的参数加上注解

   Manager find(@Param("id") String id);

6.再次运行程序，查看效果

 7.sql注入的情况