框架ssm,延展springboot构架，mybatisplus和jpa做数据持久化

1.ssm框架

1.ssm框架全称

        ssm指spring，springMVC，mybatis。使用spring实现业务对象管理，使用spring MVC负责请求的转发和视图管理，mybatis作为数据对象的持久化引擎。且注意框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容）。

        关系图如下：

        

        四层架构：

1. 控制层（Controller）： 控制层负责处理客户端的请求，接收参数，调用服务层的方法，然后返回响应给客户端。在 Spring 中，通常使用注解 @Controller 或 @RestController 来定义控制器类。控制层主要处理 HTTP 请求和响应。

2. 服务层（Service）： 服务层是应用的业务逻辑核心，负责处理具体的业务需求。它通常包含了一些业务方法，这些方法可以被控制层调用。在 Spring 中，通常使用注解 @Service 来定义服务层的类。

3. 持久层（Mapper）： 持久层负责与数据库进行交互，进行数据的读取和写入操作。在 Spring 结合 MyBatis 时，通常会定义 Mapper 接口或 DAO 接口，这些接口包含了执行数据库操作的方法。持久层还包括实体类（Entity），用于与数据库表的映射。

4. 实体类（Entity）： 实体类通常用于映射数据库表的结构，每个实体类对应数据库中的一张表，它包含了表中的字段信息。在 Spring 结合 MyBatis 中，实体类需要使用注解 @Table 来指定表名，并且字段需要使用注解 @Column 来指定字段名，以便 MyBatis 能够正确映射实体类与数据库表之间的关系

2.spring整合mybatis整合springMVC代码demo

1.创建项目

(1)打开idea

（2）写文件的包名和文件名

(3)Maven仓库的设置

(4)创建成功的界面，需要自己创建java

2.导入依赖

<dependencies>
  <!-- springMVC依赖 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.21</version>
  </dependency>
  <!-- spring JDBC依赖 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.21</version>
  </dependency>
  <!-- spring AOP依赖 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.21</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.21</version>
  </dependency>
  <!-- mybatis依赖 -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.9</version>
  </dependency>

  <!-- 然后springMVC和mybatis都交给spring管理，
  但是spring和springMVC本就一体，所以只需要整合mybatis -->
  <!-- mybatis和spring集成依赖 -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
  </dependency>
  <!-- mysql驱动 -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.9</version>
  </dependency>
  <!-- 数据库连接池 此处C3P0 -->
  <dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.1</version>
  </dependency>

  <!-- 开始计入一些其他的内容 -->
  <!-- JSTL JSP的标准变量库 -->
  <dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
  </dependency>
  <!-- 导入servlet组件 servletAPI-->
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
  </dependency>
  <!-- 单元测试-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
</dependencies>
<build>标签里面记得加上如下配置：

<resources>
  <resource>
    <directory>src/main/java</directory> <!--所在的目录-->
    <includes> <!--包括目录下的.xml 文件都会扫描到-->
      <include>**/*.xml</include>
    </includes>
  </resource>
  <resource>
    <directory>src/main/resources</directory> <!--所在的目录-->
    <includes> <!--包括目录下的.properties,.xml 文件都会扫描到-->
      <include>**/*.xml</include>
      <include>**/*.properties</include>
    </includes>
  </resource>
</resources>

3.web.xml中配置SpringMVC,Spring,字符编码过滤器，加载静态资源(因为springMVC会拦截)

<!-- 启动Spring  context-param全局参数-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:spring.xml</param-value>
</context-param>
<!-- 为了管理每一个组件，配置一个监听器-->
<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!-- Spring MVC servlet-name随便起名-->
<servlet>
  <servlet-name>dispatcherServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!--上面spring配置是全局单独配，这里是mvc自己的配置，直接写在servlet里面-->
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springMVC.xml</param-value>
  </init-param>
</servlet>
<!-- servlet-mapping拦截所有请求-->
<servlet-mapping>
  <servlet-name>dispatcherServlet</servlet-name>
  <url-pattern>/</url-pattern>
</servlet-mapping>

<!-- 字符编码过滤器 -->
<filter>
  <filter-name>characterEncodingFilter</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
    <param-name>encoding</param-name>
    <param-value>UTF-8</param-value>
  </init-param>
</filter>
<!-- servlet拦截所有是 /，字符编码过滤器拦截所有是 /* -->
<filter-mapping>
  <filter-name>characterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

<!-- 加载静态资源 -->
<servlet-mapping>
  <servlet-name>default</servlet-name>
  <url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
  <servlet-name>default</servlet-name>
  <url-pattern>*.css</url-pattern>
</servlet-mapping>
<servlet-mapping>
  <servlet-name>default</servlet-name>
  <url-pattern>*.jpg</url-pattern>
</servlet-mapping>

注意：在这一步中spring.xml，springMVC.xml这两个配置文件是在main/resources文件夹中自行创建的。

4.在 spring.xml 中配置 MyBatis 和 Spring 的整合。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
    <!-- 整合mybatis -->
    <bean id="dataSourse" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/beyounddb?useUnicode=true&amp;characterEncoding=UTF-8"></property>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <!-- 数据库连接池的设置 -->
        <property name="initialPoolSize" value="5"></property>
        <property name="maxPoolSize" value="10"></property>
    </bean>

    <!-- 配置MyBatis SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSourse"></property>
        <!--SqlSessionFactory 创建的sqlsession帮助创建自定义mapper接口的代理对象-->
        <!--*.xml 飘红，可以先在repository文件中随意创建一个test.xml文件-->
        <property name="mapperLocations" value="classpath:com/zsc/repository/*.xml"></property>
        <property name="configLocation" value="classpath:config.xml"></property>
    </bean>

    <!-- 扫描repository里面 自定义的Mapper接口 再结合上面的配置文件，mapper就可以自动生成代理对象 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.zsc.repository"></property>
    </bean>
</beans>

repository文件夹，在main/java/  com.XXX/repository。其中java和repository均为自己创建

5.第三个配置文件config.xml，配置一些 MyBatis 辅助信息，比如打印 SQL 等

<?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>
    <settings>
        <!-- 打印SQL-->
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>

    <typeAliases>
        <!-- 指定一个包名，MyBatis会在包名下搜索需要的JavaBean-->
        <package name="com.southwind.entity"/>
    </typeAliases>

</configuration>

6.配置springMVC.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">

    <!-- 启动注解驱动 -->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!-- 扫描业务代码 所有组件全扫进来，宁多不少-->
    <context:component-scan base-package="com.zsc"></context:component-scan>

    <!-- 配置视图解析器  因为是一个独立组件，不需要注入到其他组件，所以不需要id-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 配置前缀和后缀 -->
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

</beans>

7.具体业务代码

（1）实体类

package com.zsc.entity;

import lombok.Data;

@Data
public class User {
    private int uid;
    private String username;
    private  String password;
    private  String telephone;
}

(2)UserRepository

package com.zsc.repository;

import com.zsc.entity.User;

import java.util.List;

public interface UserRepository {
    public List<User> findAll();
}

(3)UserRepository.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">
<!-- 且写完之后，不用加到配置文件中，因为spring.xml的配置，已经全部扫描的容器了-->
<mapper namespace="com.zsc.repository.UserRepository">
    <!-- resultType 不用写实体类的包名是因为在config.xml中已经配置了-->
    <select id="findAll" resultType="User">
        select * from users
    </select>
</mapper>

(4)service层 UserService

package com.zsc.service;

import com.zsc.entity.User;

import java.util.List;

public interface UserService {
    public List<User> findAll();
}

(5)service实现类 UserServiceImpl

package com.zsc.service.impl;

import com.zsc.entity.User;
import com.zsc.repository.UserRepository;
import com.zsc.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public List<User> findAll() {
        return userRepository.findAll();
    }
}

（6）controller层 UserHandler

package com.zsc.controller;

import com.zsc.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/user")
public class UserHandler {
    @Autowired
    private UserService userService;

    @GetMapping("/findAll")
    public ModelAndView findAll(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("index");
        modelAndView.addObject("list",userService.findAll());
        return modelAndView;
    }
}

8.配置TomCat

2.springboot整合mybatis 和 springboot整合mybatisplus

1.mybatis的优点

1 .它消除了大量的JDBC冗余代码
2 .它有低的学习曲线
3 .它能很好地与传统数据库协同工作
4 .它可以接受SQL语句
5 .它提供了与Spring框架的集成支持
6 .它提供了与第三方缓存类库的集成支持
7 .它引入了更好的性能

2.Mybatis中的SqlSession接口和sqlSessionFactory接口

Sqlsession接口的实现类对象是Mybatis中的重要接口，我们可以使用该对象动态获得XxxxMapper.java接口的实现类对象,然后就可以调用到XxxxMapper.java接口中方法所映射的sql语句(在xml文件中配置的sql语句)。
sqlSessionFactory接口的实现类对象是一个工厂对象,专门负责来产生SqlSession对象的

另外还引入了一个类AutoConfiguredMapperScannerRegistrar，它会自动扫描@Mapper标注的接口，将这些接口认定是操作mybatis的接口

3.配置mybatis相关配置

        我们可以将原来mybatis全局配置文件mybatis-config.xml中的配置都放在yaml文件中
保持原样也可以，通过mybatis.config-location导入就可以.

#mybatis相关配置
mybatis:
#  config-location: classpath:mybatis/mybatis-config.xml  # 此配置项为mybatis全局配置文件所在位置，注意这里和下面的configuration不能同时存在
  mapper-locations: classpath:mapper/*.xml # 此配置项为sql映射文件所在位置
  configuration: #mybatis全局配置文件中的所有配置项都可以在此处配置
    map-underscore-to-camel-case: true # 开启驼峰命名

4.MyBatis Plus和MyBatis区别及怎么使用

MyBatis和MyBatis Plus是两个不同的框架，它们之间的主要区别如下：

    MyBatis Plus是在MyBatis的基础上进行的扩展和增强，因此MyBatis Plus可以使用MyBatis的所有功能，并且还提供了许多方便的工具类和方法。

    MyBatis Plus提供了很多方便的CRUD方法，例如insert、delete、update、select等，可以减少开发者的代码量。

    MyBatis Plus支持代码生成，可以根据数据库表自动生成Java实体类、Mapper接口、Mapper XML文件等。

    MyBatis Plus支持分页、乐观锁、逻辑删除、自动填充、多租户等功能，这些功能在MyBatis中需要手动实现。

    MyBatis Plus提供了注解方式和XML方式两种编程模式，可以根据自己的喜好选择使用。

总的来说，MyBatis Plus是在MyBatis框架的基础上进行的扩展和增强，提供了很多方便的工具类和方法，并且支持代码生成、分页、乐观锁、逻辑删除、自动填充、多租户等功能，可以大大提高开发效率。

使用MybatisPlus也有一些潜在的隐患，例如：

    难以理解的ORM映射关系，可能会导致在复杂的查询场景下出现问题。

    自动代码生成工具可能会生成一些冗余或不必要的代码，需要手动进行优化和改进。

    MyBatis Plus的封装过于复杂，可能会导致开发者在使用过程中出现一些难以排查和修复的问题。

    在某些情况下，使用MyBatis Plus可能会出现性能问题，需要进行优化和调整。

    MyBatis Plus的更新和维护速度可能比较慢，需要考虑到长期的项目维护和升级问题。

总的来说，MyBatis Plus是一款非常实用和方便的ORM框架，但在使用过程中需要注意其潜在的隐患和问题，避免出现不必要的麻烦和困难。

此处引用一篇文章https://www.zhihu.com/question/435240935/answer/2211846632

5.spring和springboot的介绍

Spring全称 Spring Framework，其功能有：

• IOC-控制反转，轻松实现层间解耦

• AOP- 面向切面编程，轻松实现公共代码抽取

• MVC - 开发web应用程序

• 事务 - 无需编写代码，即可实现数据库事务管理

• 测试 - 与测试框架集成、web 单元测试

        SpringBoot对Spring的改善和优化，它基于约定优于配置的思想，提供了大量的默认配置和实现。使用SpringBoot之后，程序员只需按照它规定的方式去进行程序代码的开发即可，而无需再去编写一堆复杂的配置

        SpringBoot的主要功能如下：

        起步依赖：SpringBoot以功能化的方式将需要的依赖进行组装，并且允许程序员以start的方式进行引入

        默认配置：SpringBoot实现了大量依赖框架的默认配置项，程序员无须再进行自己配置

        内置Tomcat：SpringBoot内置了一个tomcat，使用它开发的程序无需再进行tomcat部署，可直接运行

6.对于IOC和AOP的简单诠释：

1.IOC概念

IOC( 控制 反转 )是一种设计思想，它的目的是指导我们设计出更加松耦合的程序

    控制：指的是对象创建权
    反转：指的对象的创建由程序员在类中主动创建反转到由Spring容器来创建
    作用：解层与层之间的耦合，提高代码复用性。

 2.AOP

AOP( 面向切面编程 )是一种思想，它的目的就是在不修改源代码的基础上，对原有功能进行增强。SpringAOP是对AOP思想的一种实现，Spring底层同时支持jdk和cglib动态代理。
 

7.代码展示

1.依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.3.1</version>
        </dependency>
        <!-- FreeMarker被设计用来生成HTML Web页面，特别是基于MVC模式的应用程序。-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.32</version>
        </dependency>
        <dependency>
            <groupId>io.swagger</groupId>
            <artifactId>swagger-annotations</artifactId>
            <version>1.5.20</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <!-- 用于对JSON格式的数据进行解析和打包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
        <!-- 是处理Java基本对象方法的工具类包，该类包提供对字符、数组等基本对象的操作，弥补了java.lang api基本处理方法上的不足。-->
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.5</version>
            </plugin>
        </plugins>
    </build>

2.GenCode代码生成器

package com.zsc.utils;

import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.rules.DbColumnType;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.sql.Types;
import java.util.Collections;

import static com.baomidou.mybatisplus.generator.FastAutoGenerator.create;

public class GenCode {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/aaa?useUnicode=true&useSSL=false&characterEncoding=utf8";
        String driver ="com.mysql.jdbc.Driver";
        String username="root";
        String password="123456";

        create(url, username, password)
                .globalConfig(builder -> {
                    builder.author("zsc") // 设置作者
                            .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir("src\\main\\java"); // 指定输出目录
                })
                .dataSourceConfig(builder -> builder.typeConvertHandler((globalConfig, typeRegistry, metaInfo) -> {
                    int typeCode = metaInfo.getJdbcType().TYPE_CODE;
                    if (typeCode == Types.SMALLINT) {
                        // 自定义类型转换
                        return DbColumnType.INTEGER;
                    }
                    return typeRegistry.getColumnType(metaInfo);

                }))
                .packageConfig(builder -> {
                    builder.parent("com.zsc") // 设置父包名
                            .pathInfo(Collections.singletonMap(OutputFile.xml, "src\\main\\resources\\mapper")); // 设置mapperXml生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("user") ; //
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }
}

3.运行GenCode之后生成如下项目结构（没有启动文件和yml文件）：

可以检查一下service的实现类是否有@service的注解。只有有这个注解才会交给spring容器去管理。

4.根据一般依赖--配置--运用的三步，现在写配置application.yml配置文件

server:
  port: 8083
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/aaa?useUnicode=true&useSSL=false&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: 123456
mybatis-plus:
  mapper-locations: classpath*:mapper/*Mapper.xml

5.启动文件springboot的application

package com.zsc;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.zsc.mapper")
public class springbootapplicatin {
    public static void main(String[] args) {
        SpringApplication.run(springbootapplicatin.class);
    }
}

8.采用xml文件的方式也即mybatis的方式做一次findAll的查询

在mapper目录下的UserMapper中创建findAll方法

public List<User> findAll();

在resources的UserMapper.xml文价中写对应的原生sql语句

<mapper namespace="com.zsc.mapper.UserMapper">
<select id="findAll" resultType="com.zsc.entity.User">
    select * from user
</select>
</mapper>

service接口中增加findAll方法

public List<User> findAll();

service的实现类导入mapper实现findAll的具体调用

    @Resource
    private UserMapper userMapper;
    @Override
    public List<User> findAll() {
        return userMapper.findAll();
    }

controller写提供给外界的接口

    @Resource
    private UserServiceImpl userService;

    @GetMapping("/findAll")
    public HashMap findAll(){
        HashMap userHashMap = new HashMap<>();
        userHashMap.put("code",0);
        userHashMap.put("value",userService.findAll());
        return userHashMap;
    }

9.用springboot提供的selectById来完成对于id的查询

在service接口中加入findbyid方法

    public Object findbyid(long id);

写对应的实现类(selectById方法)

    @Override
    public Object findbyid(long id) {
        Object selectById =  userMapper.selectById(id);
        return  selectById;
    }

controller层的接口

    @GetMapping("/findbyid/{id}")
    public HashMap findbyid(@PathVariable("id") long id){
        HashMap userHashMap1 = new HashMap<>();
        userHashMap1.put("code",0);
        userHashMap1.put("value",userService.findbyid(id));
        return userHashMap1;
    }

10.分页的实现

1.采用xml的方式写分页的参数实现

2.通过mybatisplus提供的分页插件实现(先新建一个config包，然后新建class文件放入代码)

@configration很重要，有了这个才是加入配置，没有这个类，分页不会有效的

package com.zsc.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置MP的分页插件
 */
@Configuration
public class MybatisplusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

直接写对应的controller接口

    @GetMapping("/page/{page}/{pageSize}")
    public HashMap page(@PathVariable("page") int page ,@PathVariable("pageSize") int pageSize){
        HashMap userHashMap = new HashMap<>();

        //构造分页构造器
        Page<User> pageinfo = new Page<>(page, pageSize);
        //构造条件过滤器
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //加上条件，根据sort进行排序
        queryWrapper.orderByAsc(User::getId);
        //进行分页查询
        Page<User> userPage = userService.page(pageinfo, queryWrapper);

        userHashMap.put("code",0);
        userHashMap.put("value",userPage);
        return userHashMap;
    }

3.springboot整合jpa

1.jpa和mybatis

简介：

JPA是Java Persistence API的简称，是Java EE平台上用于ORM（对象关系映射）的规范。JPA提供了一套统一的API，使得开发人员可以更方便地进行数据库操作。相比于MyBatis-Plus，JPA更注重面向对象的思想，通过实体类和注解的方式进行操作，开发起来更加简洁高效。JPA还支持自动创建数据库表和更新表结构的功能。

MyBatis-Plus是在MyBatis框架的基础上进行了扩展和增强的一款ORM框架。MyBatis-Plus使用XML配置文件和Java代码进行数据库操作，通过编写SQL语句实现数据的增删改查。相比于JPA，MyBatis-Plus更加灵活，可以编写复杂的SQL语句，对原生SQL的支持更好。此外，MyBatis-Plus还提供了一些便捷的功能，如代码生成器、分页查询插件等

大佬资料总结：

jpa：
1:默认使用hibernate作为ORM
2:更加偏向于面向对象
3:支持多表关联（用JPAQuery，不是像mybatis那样写在xml）

mybatis：
1:避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
2:更偏向于面向数据（面向关系），致命优点：简单、可读性强

网上一直说的性能：
两个ORM框架的效率不会查特别多（毕竟一次插入万级数据，且要求ms级别，这种毕竟是极少数）。平时开发中，几百条数据的情况下，两者都差不多的。
 

2.@mapper和@repository

@Repository是属于Spring的注解，它与@Service、@Controller都可以理解为扩展的@Component注解。它们的作用都是在类上实例化bean，即把当前类对象的实现类交给Spring容器进行管理。

1、@Repository是spring的注解，@Mapper是mybatis的注解。
2、@Repository与@Mapper都可以使用，二者可以同时出现，也可以单一使用。
3、单独使用@Repository，需要配合使用MapperScannerConfigurer或者@MapperScan注解。
4、单独使用@Mapper时，可能会在编辑器出现警告，不影响程序运行。可以配合使用@Repository消除警告。（也可以在编辑器中设置忽略这种警告）

我们在使用mybatis时一般是四层结构，使用@mapper，集成jpa用到@Repository会比较好

3.代码展示

1.依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--  mysql-connector-java 是MySQL提供的JDBC驱动包,用JDBC连接MySQL数据库时必须使用该jar包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- FreeMarker被设计用来生成HTML Web页面，特别是基于MVC模式的应用程序。-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.32</version>
        </dependency>
        <dependency>
            <groupId>io.swagger</groupId>
            <artifactId>swagger-annotations</artifactId>
            <version>1.5.20</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <!-- 用于对JSON格式的数据进行解析和打包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
        <!-- 是处理Java基本对象方法的工具类包，该类包提供对字符、数组等基本对象的操作，弥补了java.lang api基本处理方法上的不足。-->
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.5</version>
            </plugin>
        </plugins>
    </build>

2.配置(修改自己想要的端口，和数据库的URL，数据库名和密码)

server:
  port: 8084

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/testdb?useUnicode=true&useSSL=false&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: 123456
  jpa:
    #自动生成数据库表（关键）
    hibernate:
      ddl-auto: update
    #jpa配置：在控制台显示Hibernate的sql(可选)
    show-sql: true
  #其他配置：关闭Thymeleaf 的缓存
  thymeleaf:
    cache: false

3.entity类

package com.zsc.entity;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
@Data
public class Student {
    @Id
    private Long sno;
    private String sname;
    private int age;
}

4.启动类

package com.zsc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class application {
    public static void main(String[] args) {
        SpringApplication.run(application.class,args);
    }
}

此时运行启动类，会在生成对应的表。

5.repository接口，类比mybatisplus的mapper接口

package com.zsc.repository;

import com.zsc.entity.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface StuRepository extends JpaRepository<Student,Long> {
    /**
     * jpa内置的CRUD方法
     *查   List<T> findAll();
     *     List<T> findAll(Sort var1);
     *     List<T> findAllById(Iterable<ID> var1);
     *增   <S extends T> List<S> saveAll(Iterable<S> var1);
     *     void flush(); //同步持久上下文环境，即将持久上下文环境的所有未保存实体的状态信息保存到数据库中。
     *     <S extends T> S saveAndFlush(S var1);
     *删   void deleteInBatch(Iterable<T> var1);
     *     void deleteAllInBatch();
     *     T getOne(ID var1);
     *     <S extends T> List<S> findAll(Example<S> var1);
     *     <S extends T> List<S> findAll(Example<S> var1, Sort var2);
     *
     *
     *     没有updata，也就是修改；所以要写修改1.封装一次JpaRepository，增加修改方法；2.先删后增
     */
}

6.controller类（在此之前你可以写一个repository的实现类，也可以向我这直接调接口）

package com.zsc.controller;

import com.zsc.entity.Student;
import com.zsc.repository.StuRepository;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

@RestController
public class StuController {
    @Resource
    private StuRepository stuRepository;

    @GetMapping("/findAll")
    public List<Student> findAll(){
        List<Student> studentList = stuRepository.findAll();
        return studentList;
    }
}

4.自定义接口（updata方法）

1.在repository层添加方法和对应的sql语句

   // 自定义的更新方法
    @Transactional
    @Modifying
    /**
     * 举例
     * @Query 注解中的JPQL（Java Persistence Query Language）查询定义了更新操作的逻辑，?1 和 ?2 是参数占位符，分别对应于方法中的 id 和 email 参数。
     * @Query("UPDATE User u SET u.email = ?2 WHERE u.id = ?1")
    **/
    @Query("update Student stu set stu.age = ?2 where stu.sno = ?1" )
    int updata(Long son ,int age);

2.service层调用repository层（service层新建）

import com.zsc.repository.StuRepository;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;


@Service
public class StuService {
    @Resource
    private StuRepository stuRepository;

    public int updata(Long sno,int age){
        return stuRepository.updata(sno,age);
    }

}

3.controller层调用

    @GetMapping("/updata/{sno}/{age}")
    public String updata(@PathVariable("sno") Long sno, @PathVariable("age") int age){
        int updata = stuService.updata(sno, age);
        if (updata >0) {
            return "success";
        }
        return "fail";
    }