ssm框架复习第一天：Mybatis

框架：对重复代码的封装，对复杂问题的封装 框架也是一个半成品的软件 ssm框架 springMVC（web层的框架） Spring（业务层service层） mybatis（dao层与数据库打交道） javaEE三层结构 ：web层 service层 dao层 MVC：将你的业务逻辑和前端视图（view）代码分离，业务逻辑是业务逻辑，前端视图是前端视图。通过控制层（controller）接收前端视图页面的请求，控制器帮你接收，然后调用后端（Model）业务逻辑层的代码帮你处理请求。 以前传统的JDBC： 1.加载驱动 Class.forname("com.jdbc.mysql.driver") 2.获取连接 DriverManager.getConnection(); 3.获取sql的执行平台（执行sql的对象）通过statement去操作数据库，执行sql语句 connection.getStatement(); 4:定义sql语句 sql="'; 5.执行sql语句（如果是查询操作的话） 6.遍历结果集，封装结果集 7.释放连接 这些重复的代码太多了，要把这些重复的代码封装起来。123,57是重复的，只有sql语句的定义和结果集的封装不一样，所有只需要我们去关注sql语句的定义和结果集的封装了。

框架：对重复代码的抽取，对复杂问题的封装

优势：能够大大提高开发效率

缺点：使用任何框架都会一定程度上影响运行效率

1.mybatis：mybatis是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 mybatis通过 xml 或注解的方式将要执行的各种statement配置起来，并通过java对象和statement 中sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。 ORM思想：ORM（object  relation Mapping ）对象关系映射，

采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc进行了封装，屏蔽了 jdbc api 底层访问细节，使我们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。

2.mybatis操作数据库步骤

 环境搭建

1.导入相关依赖

在pom.xml中导入依赖

<!--    mysql连接依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.48</version>
    </dependency>
<!--    mybatis依赖-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.3</version>
    </dependency>

2.创建数据库表和实体类

package com.swlz.domain;

public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private String address;

    public User() {
    }

    public User(Integer id, String name, Integer age, String sex, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

3.创建Dao接口

package com.swlz.dao;

import com.swlz.domain.User;

import java.io.IOException;
import java.util.List;

public interface UserDao {
    public List<User> findAll() throws IOException;
    void addUser(User user);
    void updateUser(User user);
    void deleteUser(Integer id);
}

4. 配置Dao的映射文件和主配置文件

<?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="com.swlz.dao.UserDao">
   <select id="findAll" resultType="com.swlz.domain.User">
       select * from user;
   </select>
    <insert id="addUser"  parameterType="com.swlz.domain.User">
        insert into user values(null,#{name},#{age},#{sex},#{address});
    </insert>
    <update id="updateUser" parameterType="com.swlz.domain.User">
        update user set name=#{name},age=#{age},sex=#{sex},address=#{address} where id=#{id};
    </update>
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{id};
    </delete>
</mapper>

<?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>
<!-- 外部文件的引入 jdbc.properties jdbc的配置文件  以后要修改jdbc的配置信息就在jdbc.properties这个文件修改就可以了-->
    <properties resource="jdbc.properties"></properties>
    <typeAliases>
        <!--<typeAlias type="com.swlz.domain.User" alias="user"/>-->
        <!--用package指定的包，默认都会起别名，别名就是类名-->
        <package name="com.swlz.domain"></package>
    </typeAliases>
    <!--环境信息-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <!--数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--映射文件位置-->
    <mappers>
        <mapper resource="UserDaoMapper.xml"></mapper>
<!--        <package name="com.swlz.dao"></package>-->
    </mappers>
</configuration>

jdbc.url=jdbc:mysql://localhost:3306/数据库名
jdbc.driver=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=数据库密码

5,.基本使用

package com.swlz.dao.impl;

import com.swlz.dao.UserDao;
import com.swlz.domain.User;
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;
import java.util.List;

public class UserDaoImpl implements UserDao {
    public List<User> findAll() {
        try {
//            1.加载主配置文件  这个底层是通过类加载器  getResource()   ClassLoader类加载器  把主配置文件方法类路径资源下面里面
            //通过类加载器加载类路径资源下的配置文件 得到配置文件中的信息 读出来
            InputStream is = Resources.getResourceAsStream("mybatis.xml");//里面放的是主配置文件
            // Statement对象主要是将SQL语句发送到数据库中  帮我们执行sql语句返回结果集（封装结果集对象的）
            //  2.创建SqlSessionFactory对象工厂对象connection
            //  根据主配置文件信息构建SqlSessionFactory对象 这个对象在创建的时候需要去解析主配置文件
            //  主配置文件中配置了映射配置文件，它也会帮我们去解析映射配置文件 将映射配置文件中的各种statement创建出来
            //所以sqlSessionFactory是一个重量级对象，因为它要帮我们创建连接池又要帮我们加载配置文件 对象创建时候需要消耗系统资源
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂类创建sqlsession对象 这个对象才是用来真正操作数据库的  相当于JDBC中connection，statement对象
            SqlSession sqlSession = sqlSessionFactory.openSession();//操作数据库的
            //调用相应方法 通过sqlsession去执行配置的statement  namespace+id确定唯一statement
            List<User> list = sqlSession.selectList("com.swlz.dao.UserDao.findAll", User.class);//返回User类型的数据
            //释放资源
            sqlSession.close();
            is.close();
            return list;

        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public void addUser(User user) {
        try {
            //       1.加载主配置文件
            InputStream is = Resources.getResourceAsStream("mybatis.xml");
              //2.获取SqlSessionFactory工厂对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(is);
//            3.获取操作数据库的对对象
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.调用方法
            int insert = sqlSession.insert("com.swlz.dao.UserDao.addUser", user);//参数传进去
            sqlSession.commit();//手动提交  执行增删改操作的时候会自动开启事务 需要手动提交执行sql语句才能通过

            is.close();
            sqlSession.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void updateUser(User user) {
        try {
//            1.加载主配置文件  这个底层是通过类加载器  getResource()   ClassLoader类加载器  把主配置文件方法类路径资源下面里面
            //通过类加载器加载类路径资源下的配置文件 得到配置文件中的信息 读出来
            InputStream is = Resources.getResourceAsStream("mybatis.xml");//里面放的是主配置文件
            // Statement对象主要是将SQL语句发送到数据库中  帮我们执行sql语句返回结果集（封装结果集对象的）
            //  2.创建SqlSessionFactory对象工厂对象connection
            //  根据主配置文件信息构建SqlSessionFactory对象 这个对象在创建的时候需要去解析主配置文件
            //  主配置文件中配置了映射配置文件，它也会帮我们去解析映射配置文件 将映射配置文件中的各种statement创建出来
            //所以sqlSessionFactory是一个重量级对象，因为它要帮我们创建连接池又要帮我们加载配置文件 对象创建时候需要消耗系统资源
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂类创建sqlsession对象 这个对象才是用来真正操作数据库的  相当于JDBC中connection，statement对象
            SqlSession sqlSession = sqlSessionFactory.openSession();//操作数据库的
            //调用相应方法 通过sqlsession去执行配置的statement  namespace+id确定唯一statement
            int update = sqlSession.update("com.swlz.dao.UserDao.updateUser", user);
            sqlSession.commit();


        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void deleteUser(Integer id) {
        try {
//            1.加载主配置文件  这个底层是通过类加载器  getResource()   ClassLoader类加载器  把主配置文件方法类路径资源下面里面
            //通过类加载器加载类路径资源下的配置文件 得到配置文件中的信息 读出来
            InputStream is = Resources.getResourceAsStream("mybatis.xml");//里面放的是主配置文件
            // Statement对象主要是将SQL语句发送到数据库中  帮我们执行sql语句返回结果集（封装结果集对象的）
            //  2.创建SqlSessionFactory对象工厂对象connection
            //  根据主配置文件信息构建SqlSessionFactory对象 这个对象在创建的时候需要去解析主配置文件
            //  主配置文件中配置了映射配置文件，它也会帮我们去解析映射配置文件 将映射配置文件中的各种statement创建出来
            //所以sqlSessionFactory是一个重量级对象，因为它要帮我们创建连接池又要帮我们加载配置文件 对象创建时候需要消耗系统资源
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂类创建sqlsession对象 这个对象才是用来真正操作数据库的  相当于JDBC中connection，statement对象
            SqlSession sqlSession = sqlSessionFactory.openSession();//操作数据库的
            //调用相应方法 通过sqlsession去执行配置的statement  namespace+id确定唯一statement
            int update = sqlSession.update("com.swlz.dao.UserDao.deleteUser", id);//id：参数
            sqlSession.commit();


        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：mybatis在执行增删改操作的时候，默认都会帮你开启事物，但是事物不会自动提交

 mybatis的请求参数传递与结果集封装

面试题：#{} 和 ${}的区别

1. ${}在绑定参数的时候是直接使用字符串拼接的方式   可能产生sql注入的问题

   #{}在绑定参数的时候会使用预编译Statement  能够防止sql注入

2. ${}在绑定参数的时候，如果参数是单值的情况 ${value}中的名字只能是value

   #{}在绑定参数的时候，如果参数是单值的情况 #{aaa}中的名字只能是能够自定义

3. #{}还能自动将java类型转换为jdbc类型

今日学习感受：之前欠的债，迟早到还的，学习中还是要一步一个脚印，走踏实了。一遍一遍加深自己的印象，查找自己的漏洞，并且努力补上。加油！最后一句话：勤能补拙,加油，坚持，努力！