SSM（MyBatis、Spring、SpringMVC）

声明：本文是我学习B站“狂神说java”所做的笔记，上传至此只是为了方便，要想学习，请去关注这个宝藏男孩吧

Mybatis

1、简介

（MyBatis中文文档：https://mybatis.org/mybatis-3/zh/index.html）

2、第一个MyBatis程序

思路：搭建环境 --> 导入MyBatis --> 编写代码 --> 测试

2.1、搭建环境

搭建数据库

2.2、新建项目

2.2.1、新建一个普通的maven项目

2.2.2、删除src目录

2.2.3、在pom.xml中导入maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>MyBatis-study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
    	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  	</properties>
    
    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    
    <!--build中配置resources，来放置我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resource</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

2.3、创建一个模块

2.3.1、创建mybatis的核心配置文件mybatis-config.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"/><!--事务管理-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    
    <!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
	<mappers>
        <mapper resource="com/mybatis/dao/UserMapper.xml"/>
	</mappers>
</configuration>

2.3.2、编写mybatis工具类MyBatisUtils.java

package com.mybatis.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;

//SqlSessionFactory --> SqlSession
public class MyBatisUtils {
   
    private static SqlSessionFactory sqlSessionFactory;
    static {
   

        try {
   
            //使用mybatis第一步，获取SqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    }
    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    // 你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    public static SqlSession getSqlSession(){
   
        return sqlSessionFactory.openSession();
    }
}

2.4、编写代码

2.4.1、创建实体类User.java

package com.mybatis.pojo;

//实体类
public class user {
   
    private int id;
    private String name;
    private String pwd;

    public user() {
    }

    public user(int id, String name, String pwd) {
   
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
   
        return id;
    }

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

    public String getName() {
   
        return name;
    }

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

    public String getPwd() {
   
        return pwd;
    }

    public void setPwd(String pwd) {
   
        this.pwd = pwd;
    }
}

2.4.2、创建Dao接口UserDao.java

package com.mybatis.dao;

import com.mybatis.pojo.User;

import java.util.List;

public interface UserDao {
   
    List<User> getUserList();
}

2.4.3、创建实现接口的配置文件UserMapper.xml

接口实现类由原来的UserDaoImpl转变为一个Mapper配置文件

<?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绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.mybatis.dao.UserDao">
    <!--查询语句-->
   <select id="getUserList" resultType="com.mybatis.pojo.User">
       select * from mybatis
   </select>
</mapper>

2.5、测试

Junit测试类UserDaoTest.java

package com.mybatis.dao;

import com.mybatis.pojo.User;
import com.mybatis.util.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
   
    @Test
    public void test(){
   
        //第一步：获取SqlSession对象
        SqlSession sqlSession=MyBatisUtils.getSqlSession();

        //执行SQL
        //方式一：getMapper
        UserDao userDao=sqlSession.getMapper(UserDao.class);
        List<User> userList=userDao.getUserList();

        for (User user : userList) {
   
            System.out.println(user);
        }

        //关闭SqlSession
        sqlSession.close();
    }
}

2.6、注意点：

2.6.1、maven环境错误

**解决方法：**https://www.cnblogs.com/phpdragon/p/7216626.html

2.6.2、数据库连接失败

解决方法：检查数据库版本与Driver版本是否一致

**2.6.3、MapperRegistry错误**

org.apache.ibatis.binding.BindingException: Type interface com.mybatis.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？

核心配置文件中注册mappers

解决方法：在MyBatis的核心配置文件mybatis-config.xml中添加注册

<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
        <mapper resource="com/mybatis/dao/UserMapper.xml"/>
</mappers>

2.6.4、java.lang.ExceptionInInitializerError

解决方法：在pom.xml中添加build

<!--build中配置resources，来放置我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resource</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
            </resource>
        </resources>
    </build>

**2.6.5、UTF-8错误**

解决方法：在pom.xml中加以下代码

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

2.6.6、Could not find resource mybatis-config.xml

解决方法：注释或删除pom.xml中的

<packaging>pom</packaging>

3.CRUD

3.1、注意点

1、增删改需要提交事务！

2、namespace中的包名要和Dao/Mapper接口的包名一致！

3、id：**就是对应的namespace中的方法名；

resultType：Sql语句执行的返回值；

**parameterType：**参数类型

3.2、Select

3.2.1 、编写接口

 //根据用户id查询
    User getUserById(int id);

3.2.2、编写对应的Mapper中的sql语句

 <!--根据id查询-->
    <select id="getUserById" resultType="com.mybatis.pojo.User" parameterType="int">
        select * from users where id = #{id}
    </select>

3.2.3、测试

  //按id查询
    @Test
    public void getUserById(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        UserDao userList=sqlSession.getMapper(UserDao.class);
        User user=userList.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }

3.3、Insert

3.3.1 、编写接口

    //插入用户
    int addUser(User user);

3.3.2、编写对应的Mapper中的sql语句

 <!--插入用户-->
    <insert id="addUser" parameterType="com.mybatis.pojo.User">
        insert into users (id,name,psw) values(#{id},#{name},#{psw})
    </insert>

3.3.3、测试

//增加
    @Test
    public void addUser(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        UserDao userList=sqlSession.getMapper(UserDao.class);
        int res=userList.addUser(new User(4,"王五","123"));
        if(res>0)
            System.out.println("插入成功");

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

3.4、Updeta

3.4.1 、编写接口

//修改用户
    int updateUser(User user);

3.4.2、编写对应的Mapper中的sql语句

  <!--修改用户-->
    <update id="updateUser" parameterType="com.mybatis.pojo.User">
        update users set name=#{name},psw=#{psw} where id=#{id}
    </update>

3.4.3、测试

 //修改
    @Test
    public void updateUser(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        UserDao userList=sqlSession.getMapper(UserDao.class);
        int res=userList.updateUser(new User(4,"汪玲","12345"));
        if(res>0)
            System.out.println("修改成功");
        sqlSession.commit();
        sqlSession.close();
    }

3.5、Delete

3.5.1 、编写接口

 //删除用户
    int deleteUser(int id);

3.5.2、编写对应的Mapper中的sql语句

 <!--删除用户-->
    <delete id="deleteUser" parameterType="int">
        delete from users where id=#{id}
    </delete>

3.5.3、测试

 //删除
    @Test
    public void deleteUser(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        UserDao userList=sqlSession.getMapper(UserDao.class);
        int res=userList.deleteUser(4);
        if(res>0)
            System.out.println("删除成功");
        sqlSession.commit();
        sqlSession.close();
    }

3.6、错误分析

1、标签对应匹配

2、resource绑定mapper需要使用路径

3、程序配置文件必须符合规范

4、NullPointException,没有注册到资源

5、输出的xml存在中文乱码问题

6、maven资源没有导出问题

3.7、万能的Map

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map!

Map传递参数，直接在sql中取出key即可 【parameterType=“map”】

对象传递参数，直接在sql中取对象的属性即可 【parameterType=“Object”】

只有一个基本类型参数的情况下，可以直接在sql中取到！

多个参数用Map，或者注解！

3.7.1 、编写接口

    //万能的Map
    int addUser2(Map<String,Object> map);

3.7.2、编写对应的Mapper中的sql语句

<!--万能的Map
    传递Map的key
    -->
    <insert id="addUser2" parameterType="map">
        insert into users (id,name,psw) values(#{userId},#{userName},#{userPsw})
    </insert>

3.7.3、测试

  @Test
    public void addUser2(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        UserDao userList=sqlSession.getMapper(UserDao.class);
        Map<String,Object> map=new HashMap<String, Object>();
        map.put("userId",5);
        map.put("userName","英诺华");
        map.put("userPsw","12345");
        int res=userList.addUser2(map);
        if(res>0)
            System.out.println("插入成功");

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

3.8、模糊查询

模糊查询怎么写？

1、Java代码执行时，传递通配符% %；

 //模糊查询
    @Test
    public void getUserLike(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        UserDao userDao=sqlSession.getMapper(UserDao.class);

        List<User> userLists=userDao.getUserLike("%李%");

        for (User user : userLists) {
   
            System.out.println(user);
        }
        sqlSession.close();
    }

2、在sql拼接中使用通配符！

 <!--模糊查询-->
    <select id="getUserLike" resultType="com.mybatis.pojo.User">
        select * from users where name like "%"#{value}"%"
    </select>

4、配置解析

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。配置文档的顶层结构如下：

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

4.1、核心配置文件

mybatis-config.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"/><!--事务管理-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    
    <!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
	<mappers>
        <mapper resource="com/mybatis/dao/UserMapper.xml"/>
	</mappers>
</configuration>

4.2、环境变量

MyBatis 可以配置成适应多种环境

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

学会使用多套环境

MyBatis默认事务管理器：JDBC，连接池：POOLED

4.3、属性（properties）

我们可以通过properties属性来实现引用配置文件

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】

编写配置文件

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=root

在核心配置文件中引入

<!--核心配置文件-->
<configuration>
    <!--引入外部配置文件-->
    <properties resource="db.properties"/>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/><!--事务管理-->
            <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>

    <!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
    <mappers>
        <mapper resource="com/mybatis/dao/UserMapper.xml"/>
    </mappers>

</configuration>

1、可以直接引入外部文件

2、可以在其中增加一些属性配置

3、如果两个文件有同一个字段，优先使用外部配置文件！

4.4、别名

1、类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写。

 <typeAliases>
        <!--可以给实体类起别名-->
        <typeAlias type="com.mybatis.pojo.User2" alias="User2"/>
 </typeAliases>

2、也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

扫描实体类的包，他的默认别名就是这个类的类名，首字母建议小写！

<typeAliases>
        <!--扫描包-->
        <package name="com.mybatis.pojo" />
</typeAliases>

在实体类比较少时使用第一种方式；

如果实体类较多，建议使用第二种方式；

第一种方式可以DIY（自定义）别名，第二种方式则不行，如果非要改，需要在实体类上增加注解

//实体类
@Alias("hello")
public class User2 {
   
    private int id;
    private String name;
    private String psw;
}

4.5、设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

4.6、其他配置

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）

mybatis-generator-core

mybatis-plus

通用mapper

4.7、映射器

MapperRegistry：注册绑定我们的Mapper文件；

方式一：使用相对于类路径的资源引用

	<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
    <mappers>
        <!-- 方式一：使用相对于类路径的资源引用 -->
        <mapper resource="com/mybatis/dao/UserMapper.xml"/>
    </mappers>

方式二：使用class文件绑定注册

 <!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
    <mappers>
        
        <!-- 方式一：使用相对于类路径的资源引用 -->
    	<!--<mapper resource="com/mybatis/dao/UserMapper.xml"/>-->
        
        <!-- 方式二：使用class文件绑定注册-->
        <mapper resource="com.mybatis.dao.UserMapper"/>
        
    </mappers>

注意点：

1、接口和他的Mapper配置文件必须同名！

2、接口和他的Mapper配置文件必须在同一个包下！

方式三：将包内的映射器接口实现全部注册为映射器

  <!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
    <mappers>
        
        <!-- 方式一：使用相对于类路径的资源引用 -->
        <!--<mapper resource="com/mybatis/dao/UserMapper.xml"/>-->
        
        <!-- 方式二：使用class文件绑定注册-->
        <!-- <mapper class="com.mybatis.dao.UserMapper"/>-->
        
        <!-- 方式三：将包内的映射器接口实现全部注册为映射器-->
        <package name="com.mybatis.dao"/>

    </mappers>

注意点：

使用扫描包进行注入绑定，注意点同方式二使用class文件绑定注册。

1、接口和他的Mapper配置文件必须同名！

2、接口和他的Mapper配置文件必须在同一个包下！

4.8、生命周期和作用域

作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题！

SqlSessionFactoryBuilder

一旦创建了 SqlSessionFactory，就不再需要它了

局部变量

SqlSessionFactory

说白了就是可以想象为：数据库连接池

SqlSessionFactory*一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例

SqlSessionFactory 的最佳作用域是应用作用域

最简单的就是使用单例模式或者静态单例模式

SqlSession

连接到连接池的一个请求

SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域

用完之后需要赶紧关闭，否则资源被占用

这里面的每一个Mapper，就代表一个具体的业务！

5、解决属性名和字段名不一致的问题(ResultMap)

数据库中的字段

新建一个项目，拷贝之前的，测试实体类字段不一致的

//实体类
public class User {
   
    private int id;
    private String name;
    private String password;

解决方法：

1、起别名

2、resultMap

结果集映射

数据库字段：id  name  psw
实体类属性：id  name  password

<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.mybatis.dao.UserMapper">
    <!--结果集映射-->
    <resultMap id="UserMap" type="User">
        <!--column数据库中的字段 property实体类中的属性-->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="psw" property="password"/>
    </resultMap>
    <!--根据id查询-->
    <select id="getUserById" resultMap="UserMap">
        select * from users where id = #{id}
    </select>

resultMap 元素是 MyBatis 中最重要最强大的元素

ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了

ResultMap 的优秀之处——你完全可以不用显式地配置它们

6、日志

6.1、日至工厂

如果一个数据库操作出现异常，需要拍错，日志就是最好的助手

曾经：sout,debug

现在：日志工厂

SLF4J

LOG4J 【掌握】

LOG4J2

JDK_LOGGING

COMMONS_LOGGING

STDOUT_LOGGING 【掌握】

NO_LOGGING

在MyBatis中具体使用那一个日志实现，在设置中设置

STDOUT_LOGGING标准日志输出

在MyBats核心配置文件中配置我们的日志

<settings>
        <setting name="logImpl" 	value="STDOUT_LOGGING"/>
</settings>

6.2、LOG4J

什么是Log4j？

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件。

我们也可以控制每一条日志的输出格式

通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程

通过一个配置文件来灵活地进行配置，而不需要修改应用的代码

6.2.1、先导入LOG4J的包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

6.2.2、log4j.properties

### 配置根 ###
log4j.rootLogger = DEBUG,console ,file

### 设置输出sql的级别，其中logger后面的内容全部为jar包中所包含的包名 ###
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG

### 配置输出到控制台 ###
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.Threshold = DEBUG
log4j.appender.console.layout.ConversionPattern = [%c] -%m%n

### 配置输出到文件 ###
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File = ./logs/mybatis.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold = DEBUG
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = [%p] [%-d{
   yy-MM-dd}] [%c] %m%n

6.2.3、配置log4j为日志的实现

 <settings>
        <setting name="logImpl" value="LOG4J"/>
</settings>

6.2.4、log4j的使用，直接测试运行刚才的查询

简单使用

1、在要是用log4j的类中导入包 import org.apache.log4j.Logger;

2、日志对象，加载参数为当前类的class

static Logger logger= Logger.getLogger(UserDaoTest.class);

3、日志级别

 @Test
    public void testLog4j(){
   
        logger.info("info:进入了testLog4j");
        logger.debug("debug:进入了testLog4j");
        logger.error("error:进入了testLog4j");
    }

7、分页

思考，为什么分页？

减少数据的处理量

使用limit分页

语法：select * from users limit startIndex,pagesize ;
	 select * from users limit n;  //[0,n]

7.1使用MyBatis实现分页

1、接口

 //分页
    List<User> getUserByLimit(Map<String,Integer> map);

2、Mybatis.xml

 <select id="getUserByLimit" parameterType="map" resultType="User">
        select *from users limit #{startIndex},#{pageSize};
 </select>

3、测试

  @Test
    public void getUserByLimit(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        UserMapper userMapper= sqlSession.getMapper(UserMapper.class);
        Map<String,Integer> map=new HashMap<String,Integer>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List<User> userList=userMapper.getUserByLimit(map);
        for(User user:userList){
   
            System.out.println(user);
        }
        sqlSession.close();
    }

7.2、RowBounds分页

1、接口

 //分页2
    List<User> getUserByRowBounds(Map<String,Integer> map);

2、mapper.xml

 <select id="getUserByRowBounds" resultType="User">
        select *from users ;
 </select>

3、测试

 @Test
    public void getUserByRowBounds(){
   
        SqlSession sqlSession=MyBatisUtils.getSqlSession();
        //RowBounds实现
        RowBounds rowBounds = new RowBounds(1, 2);
        //通过JAVA代码层面实现分页
        List<User> userList=sqlSession.selectList("com.mybatis.dao.UserMapper.getUserByRowBounds",null,rowBounds);
        for(User user:userList){
   
            System.out.println(user);
        }
        sqlSession.close();
    }

7.3、分页插件

8、使用注解开发

8.1、面向接口编程

在这里插入图片描述

8.2、使用注解开发

1、注解在接口上实现

  //获取全部查询
    @Select("select * from users")
    List<User> getUserList();

2、在核心配置文件中绑定接口

<mappers>
        <mapper class="com.mybatis.dao.UserMapper"/>
</mappers>

3、测试

本质：反射机制实现

底层：动态代理

MyBatis详细执行流程

在这里插入图片描述

8.3、CRUD

关于@Param()注解

基本类型参数或者String类型，需要加上

引用类型不用

如果只有一个基本类型，可以忽略，但是建议使用

我们在SQL中引用的就是这里@Param()中设定的属性名！

#{}和${}区别

#{}能防止SQL注入

1、在工具类创建时实现自动提交事务

public static SqlSession getSqlSession(){
   
     return sqlSessionFactory.openSession(true);
}

2、编写接口，增加注解

 //获取全部查询
    @Select("select * from users")
    List<User> getUserList();
    //方法存在多个参数，参数前面必须添加@Param("uid")注解
    @Select("select * from users where id=#{uid}")
    User getUserById(@Param("uid") int id);

    @Insert("insert into users(name,psw,id) values(#{name},#{password},#{id})")
    int addUser(User user);

3、测试类

【注意：必须要将接口注册绑定到核心配置文件中！】

//查询
    @Test
    public void getUserList() {
   
        //第一步：获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
//底层主要用运反射
        //第二步执行SQL
        //getMapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.getUserList();
        for (User user : users) {
   
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();

    }

    @Test
    public void getUserById() {
   
        //第一步：获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //底层主要用运反射
        //第二步执行SQL
        //getMapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.getUserById(2);
        System.out.println(user);
        //关闭SqlSession
        sqlSession.close();

    }

    @Test
    public void addUser() {
   
        //第一步：获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //底层主要用运反射
        //第二步执行SQL
        //getMapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        int result = userMapper.addUser(new User(10,"哈萨克","1234"));
        if(result>0)
            System.out.println("插入成功！");
        //关闭S
        qlSession
        sqlSession.close();

    }

9、Lombok

java library、plugs、build tools

//常用注解
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows

说明：

@Data:无参构造、get、set、toString、hashCode、equals
@AllArgsConstructor：有参构造
@NoArgsConstructor：无参构造

使用步骤

1、在IDEA中安装lombok插件

2、在项目中导入lombok的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.10</version>
    <scope>provided</scope>
</dependency>

3、在实体类上加注解

//实体类
@Data
@AllArgsConstructor
public class User {
   
    private int id;
    private String name;
    private String password;
}

10、多对一处理

10.1、多对一

多个学生对应一个老师

对于学生这边而言，关联…多个学生，关联一个老师【多对一】

对于老师而言，集合…一个老师，有很多学生【一对多】

10.2、SQL

create table teacher(
       `id` INT(10) NOT NULL,
       `name` VARCHAR(30) DEFAULT NULL,
       PRIMARY KEY(`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO `teacher` VALUES(1,"秦老师");

create table student(
       `id` INT(10) NOT NULL,
       `name` VARCHAR(30) DEFAULT NULL,
       `tid` INT(10) DEFAULT NULL,
       PRIMARY KEY(id),
       KEY `fktid` (`tid`),
       CONSTRAINT `fktid` FOREIGN KEY(`tid`) REFERENCES `teacher`(`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO student(`id`,`name`,`tid`) VALUES(1,"小明",1);
INSERT INTO student(`id`,`name`,`tid`) VALUES(2,"小红",1);
INSERT INTO student(`id`,`name`,`tid`) VALUES(3,"小张",1);
INSERT INTO student(`id`,`name`,`tid`) VALUES(4,"小李",1);
INSERT INTO student(`id`,`name`,`tid`) VALUES(5,"小王",1);

10.3、测试环境搭建

1、导入lombok

2、建立实体类Teacher，Student

@Data
@NoArgsConstructor
public class Student {
   
    private int id;
    private Stri