# springmvc-learn

**Repository Path**: hrbu-2022/springmvc-learn

## Basic Information

- **Project Name**: springmvc-learn
- **Description**: 学习spirngmvc 知识点，   以及ssm整合
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-03-14
- **Last Updated**: 2025-03-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# SpringMVC的入门项目

## 创建项目

- 创建web项目 使用IDEA提供的maven插件中 的 骨架 org.apache.maven.archetypes:maven-archetype-webapp
- ![image-20250314093622904](imgs/image-20250314093622904.png)
- ![image-20250314093746101](imgs/image-20250314093746101.png)

1. 添加 src/main/java

2. src/main/resource

3. src/test/main


![image-20250314093843605](imgs/image-20250314093843605.png)







- 添加spirngmvc的依赖

```xml
<?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>com.neuedu.spirngmvc</groupId>
  <artifactId>springmvc-01-web-helloworld</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc-01-web-helloworld Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.version>5.3.39</spring.version>
    <junit.version>5.11.4</junit.version>
  </properties>

  <dependencies>
    <!-- 单元测试库 -->
    <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
  
  
    <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
    <!-- spring-webmvc会依赖spring-web  包含 web bean、cort、context、Expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
  </dependencies>

  
</project>

```

- 在web.xml中添 注册  DispatcherServlet

![img](imgs/1604979788776-2609b82f-59e6-4ea2-9fb0-9a7cb9095288.webp)

```xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app
    version="4.0"
    xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:javaee="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:xml="http://www.w3.org/XML/1998/namespace"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd">
  <display-name>Archetype Created Web Application</display-name>
  
  
  
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 也可不配置参数，默认加载 /WEB-INF/springmvc-servlet.xml -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc-servlet.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>
```



- 添加启动  配置文件
  - 注册Bean（@Controller ）
  - 让@Controller是特殊的Bean， 能相应 HandlerMapping   被 HandlerAdapter 执行

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/mvc
  http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--
    此标签能够自动加载注解的处理器映射和注解的处理器适配，
    而且还默认加载了很多其他方法。 比如：参数绑定到控制器参数、json转换解析器
    -->
    <mvc:annotation-driven />
    <!-- 开启注解扫描，将包下带有@Controller注解的类纳入Spring容器中-->
    <context:component-scan base-package="com.neuedu.springmvc.controller" />
</beans>
```

- 编写一个Controller （IndexController）
  - public  String  index(){
    - return  "success"
  - }
- 设置 url  和 该方法的关系
  - @RequestMapping

```java
package com.neuedu.springmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/149:44
 */
@Controller
public class IndexController {



    @ResponseBody
    @RequestMapping("/index")
    public String index(){
        return "success";
    }

}

```

- 将项目添加到Tomcat中 并发布

![image-20250314094922058](imgs/image-20250314094922058.png)

![image-20250314094952361](imgs/image-20250314094952361.png)

![image-20250314095022813](imgs/image-20250314095022813.png)

![image-20250314095031471](imgs/image-20250314095031471.png)

![image-20250314095049367](imgs/image-20250314095049367.png)





- 使用URL 请求 Hanlder（Controller）
  - http://localhost:8080/web/index

![image-20250314095124249](imgs/image-20250314095124249.png)

# APIFox

常用与开发调试（http、rcp）

![image-20250314104211868](imgs/image-20250314104211868.png)



# 常用注解

- @RequestMapping: 映射 路径和 方法的关系

1. @RequestMapping 应用在处理器类上： 设置请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以 / 开头。 它出现的目的是为了使我们的URL可以按照模块化管理。
2. @RequestMapping 应用在处理器类的某个方法上：请求URL的第二级访问目录。
3. @RequestMapping注解中常用属性有：
   value：用于指定请求的URL。 method：用于指定请求的方式。

可以使用  是@RequestMapping(= RequestMethod.GET)的缩写。

- method 	

  - ```
    GET,
    HEAD,
    POST,
    PUT,
    PATCH,
    DELETE,
    OPTIONS,
    TRACE;
    ```

![image-20250314110534022](imgs/image-20250314110534022.png)

当方法不支持的时候 spirngmvc响应 http405

![image-20250314110737190](imgs/image-20250314110737190.png)

- ResponseBody 将方法的返回值，直接响应给浏览器（客户端）

> ResponseBody注解的作用是将controller的方法返回的数据写入到response对象的body区，也就是直接将数据写入到输出流中，效果等同于使用 response.getWriter() 输出流对象向前端返回数据。需要注意的是，在使用此注解之后，响应不会再走视图处理器。







# 跨域

```
<mvc:cors>

    <mvc:mapping path="/api/**"
        allowed-origins="https://domain1.com, https://domain2.com"
        allowed-methods="GET, PUT"
        allowed-headers="header1, header2, header3"
        exposed-headers="header1, header2" allow-credentials="true"
        max-age="123" />

    <mvc:mapping path="/resources/**"
        allowed-origins="https://domain1.com" />

</mvc:cors>
```





# 参数绑定 日期的问题处理

```java
package com.neuedu.springmvc.controller;

import com.neuedu.springmvc.po.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/188:56
 */
@RestController
@RequestMapping("/date")
public class DateController {


    /***
     // *  http://localhost:8080/web/date/getDate?username=admin&birthday=2025-03-18 08:59:05
     // *  http://localhost:8080/web/date/getDate?username=admin&birthday=2025/03/18 08:59:05
     // *  http://localhost:8080/web/date/getDate?username=admin&birthday=08:59:05 2025/03/18
     * @param user
     * @return
     */
    @RequestMapping("/getDate")
    public String getDate(User user){

        return  user.toString();

    }





}
```

传递 日期格式的时候  页面报 400错误

Spirngmvc内置了一些 能够将String类型的参数 转换成  （int、float、String），当转换Date类型时 无法处理 需要自定义一个  StringToDateConvert



![image-20250318090411743](imgs/image-20250318090411743.png)

处理方式

- 编写一个 Convert  （String---Date）
- 配置Convert 到 WebMvc的流程中



转换器

````java
package com.neuedu.springmvc.convert;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/189:05
 */
public class MyStringToDateConvert implements Converter<String, Date> {
    @Override
    public Date convert(String source) {

        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-DD HH:mm:ss");
        Date date = null;

        try {
            date = sdf.parse(source);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }

        return date;
    }
}

````



在xml(spirng-servlet.xml)文件中配置转换器

```xml
<mvc:annotation-driven conversion-service="conversionService"  />



<!-- 提供一个  转换器的 service -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean" >
    
    <property name="converters">
        <list>
            <bean class="com.neuedu.springmvc.convert.MyStringToDateConvert"></bean>
        </list>
    </property>
    
</bean>
```

# 序列化日期

从数据库中查询出来的信息以内存对象的形式存在 使用的是 Date 类型， 需要序列化出一个格式（默认是时间戳），如果需要转换成 时分秒 年月日等格式， 

可以使用ObjectMapper 进行配置（全局）或者在日期类型上添加@JsonFromat

```
@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date birthday;
```



```
package com.neuedu.springmvc.po;

import com.fasterxml.jackson.annotation.JsonFormat;

import java.util.Date;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/1715:33
 */
public class User {

    private String username;
    private String password;
    private int age;
    private String expireDate;

    // @JsonFormat(pattern="yyyy-MM-dd")
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date birthday;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

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

    public String getExpireDate() {
        return expireDate;
    }

    public void setExpireDate(String expireDate) {
        this.expireDate = expireDate;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", expireDate='" + expireDate + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}
```

![image-20250318095431000](imgs/image-20250318095431000.png)

# 上传

- 添加依赖
  - common-fileupload
  - common-io

- 在Spring容器中添加一个 MultipartResolver
  - CommonsMultipartResolver  使用common-fileupload  解析上传的内容（**为了兼容性使用第三方的**）
  - StandardServletMultipartResolver  使用原生Servlet 的  getPart（）  需要的 Servlet版本是 3.x
- 自定义一个Controller 用于接受上传文件的  信息
  - MultipartFile myFile
- 提供一个上传文件的表单

## 添加依赖

```xml
<?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>com.neuedu.springmvc</groupId>
  <artifactId>springmvc-03-upload</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc-03-upload Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  
  
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.version>5.3.39</spring.version>
    <junit.version>5.11.4</junit.version>
    <servlet.version>4.0.1</servlet.version>
  </properties>
  
  <dependencies>
    <!-- 单元测试库 -->
    <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    
    
    <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
    <!-- spring-webmvc会依赖spring-web  包含 web bean、cort、context、Expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    
    <!-- jackson相关依赖 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
    
    
    
    <!--   在编一个 的时候 需要Servlet jar -->
    <!--   https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>
  
  
  
    
    
    
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
  </dependencies>
  
  
  
</project>
```

## 配置解析器

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/mvc
  http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--
    此标签能够自动加载注解的处理器映射和注解的处理器适配，
    而且还默认加载了很多其他方法。 比如：参数绑定到控制器参数、json转换解析器
    
    conversion-service 配置转换器
    -->
    <mvc:annotation-driven   />
    

    
    <!-- 开启注解扫描，将包下带有@Controller注解的类纳入Spring容器中-->
    <context:component-scan base-package="com.neuedu.springmvc" />
    
    
    <!--必须要有此id名 -->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--上传文件大小限制，单位：字节 -->
        <property name="maxUploadSize" value="5000000"></property>
    </bean>
    
    
    
</beans>
```

## controller 

编写一个用于接受 上传的信息、

```java
package com.neuedu.springmvc.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.UUID;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/1810:40
 */
@RestController
public class UploadController {


    @RequestMapping("/upload")
    public String upload(MultipartFile file) throws IOException {

        System.out.println(file.getOriginalFilename());
        System.out.println(file.getSize());
        System.out.println(file.getName());

        String ext = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf("."));
        String newFileName = UUID.randomUUID().toString()+ext;

        file.transferTo(new File("D:\\upload",newFileName));
        return "success";

    }


}

```

## 表单

用于提交  上传文件的请求

为了测试方便 将代码写在 index.jsp中

```html
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>

<form action="http://localhost:8080/web/upload" method="post" enctype="multipart/form-data">


    <input type="file" name="file" />


    <input type="submit" value="上传">


</form>
</body>
</html>

```



测试

访问 upload.html

![image-20250318105345552](imgs/image-20250318105345552.png)

![image-20250318105440646](imgs/image-20250318105440646.png)



![image-20250318105452907](imgs/image-20250318105452907.png)



## 拦截器

- 搭建一个springmvc的项目
  - 添加依赖
  - 配置DispathcerServlet
  - spring-servlet.xml
  - 包扫描、注解驱动  @RequestMapping
  - Controller
  - 发布到Tomcat
  - 测试
    - http://localhost:8080/web/user/getuser

## 使用拦截器

- 自定义一个拦截器 需要实现 HandlerInterceptor

```java
package com.neuedu.springmvc.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/1811:31
 */
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("LoginInterceptor.preHandle");
        return true;
    }


    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("LoginInterceptor.postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("LoginInterceptor.afterCompletion");

    }
}
```

- 添加spirngmvc的配置中
  - <mvc:>

```xml
<!-- 配置拦截器 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!--
            /*      /index  √         /user/getuser  x
           /*/**    /index  √         /user/getuser  √
         -->
        <mvc:mapping path="/*/**"/>
        <bean class="com.neuedu.springmvc.interceptor.LoginInterceptor"></bean>
    </mvc:interceptor>
    
</mvc:interceptors>
```

- 测试

![image-20250318113648581](imgs/image-20250318113648581.png)



- preHandle  ： 优先于Controller 之前执行
  -  返回 true，能够正常执行后续的代码（Controller）
  - 返回false  请求不会发送给Controller		
- postHandle  : 执行完 Controller方法之后 执行此方法 ，一旦出现错误异常，不会执行

![image-20250318113951350](imgs/image-20250318113951350.png)

- afterCompletion  :  Controller方法之后执行，无论是否出现异常

没有报错

- LoginInterceptor.preHandle
- UserController.getUser
- LoginInterceptor.postHandle
- LoginInterceptor.afterCompletion

# RESTful

http://127.0.0.1:8080/web/get?id=10

http://localhost:8080/web/user/get/1

http://localhost:8080/web/user/get/2

http://localhost:8080/web/user/get/3

http://localhost:8080/web/user/get/4





http://localhost:8080/web/user/post/1/admin/12456

http://localhost:8080/web/user/post/2/root/123456



# ssm整合(配置文件)

- webapp项目
- 添加依赖
  - springmvc
  -  spirng  +mybatis
    - aop
    - spring -jdbc
    - mybatis......
  - 单元测试
- 搭建SpringMVC、
  - web.xml-- DispatcherServlet
  - spring-ssm-xml
    - 包扫描
    - 注解驱动
  - Controller
- Mybaits整合
  - 配置文件中配置
    - 数据源
    - SqlSessionFactory
    - Mapper 包扫描（IOC容器中注册   Mapper.java ）
- Service

- 根据ID获取部门  controller-service-mapper

## 创建项目

webapp骨架\

com.neuedu.ssm

## 添加依赖 

```xml
<?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>com.neuedu.ssm</groupId>
  <artifactId>springmvc-05-ssm-xml</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc-05-ssm-xml Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  
  
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.version>5.3.39</spring.version>
    <junit.version>5.11.4</junit.version>
    <servlet.version>4.0.1</servlet.version>
  
    <mysql.version>8.0.33</mysql.version>
    <mybatis.version>3.5.19</mybatis.version>
    <mybatis.spring.version>2.0.0</mybatis.spring.version>
    <druid.version>1.2.24</druid.version>
    <jackson.version>2.9.0</jackson.version>
    
    
    
  </properties>
  
  <dependencies>
    <!-- 单元测试库 -->
    <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <!-- spring-webmvc会依赖spring-web  包含 web bean、cort、context、Expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
      <scope>test</scope>
    </dependency>
    
    <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
    <!-- spring-webmvc会依赖spring-web  包含 web bean、cort、context、Expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    
    <!-- jackson相关依赖 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    
    
    
    <!--   在编一个 的时候 需要Servlet jar -->
    <!--   https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>
    
  
    <!-- jdbc、事务的支持 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
  
  
  
  
    <!-- 数据库驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
  
    <!-- 数据库驱动 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
  
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>
  
  
    <!-- Datasource 数据库  Druid  -->
    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>${druid.version}</version>
    </dependency>

  </dependencies>




</project>
```

## 搭建spirngmvc

### 配置  web.xml

- 配置DispatcherServlet

```xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app
    version="4.0"
    xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:javaee="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:xml="http://www.w3.org/XML/1998/namespace"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd">
  <display-name>Archetype Created Web Application</display-name>
  
  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc-ssm.xml</param-value>
    </init-param>
    <!-- 启动Tomcat时直接加载 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>
```

### 配置spirng-ssm.xml

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/mvc
  http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--
    此标签能够自动加载注解的处理器映射和注解的处理器适配，
    而且还默认加载了很多其他方法。 比如：参数绑定到控制器参数、json转换解析器
    conversion-service 配置转换器
    -->
    <mvc:annotation-driven   />
    
    <!-- 开启注解扫描，将包下带有@Controller注解的类纳入Spring容器中-->
    <context:component-scan base-package="com.neuedu.ssm" />


</beans>
```

### 编写Controller(DeptController)

```java
package com.neuedu.ssm.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/1814:33
 */
@RestController
@RequestMapping("/dept")
public class DeptController {


    @GetMapping("/{id}")
    public String getByid(@PathVariable int id){

        return "invoke get method  id:"+id;
    }



}
```

### 部署

将项目添加到Tomcat 部署并测试

http://localhost:8080/ssm/dept/10

![image-20250318143644651](imgs/image-20250318143644651.png)



## 整合Mybatis

- 依赖已经完成了
- 在IOC容器中注册  数据源、SqlSessionFactory、Mapper代理对象

### 配置mybatis(在SpirngIOC容器中)

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/mvc
  http://www.springframework.org/schema/mvc/spring-mvc.xsd
 http://www.springframework.org/schema/tx
  http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--
    此标签能够自动加载注解的处理器映射和注解的处理器适配，
    而且还默认加载了很多其他方法。 比如：参数绑定到控制器参数、json转换解析器
    conversion-service 配置转换器
    -->
    <mvc:annotation-driven   />
    
    <!-- 开启注解扫描，将包下带有@Controller注解的类纳入Spring容器中-->
    <context:component-scan base-package="com.neuedu.ssm" />
    
    
    <!-- 加载jdbc的属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    
    <!-- 配置Spring提供的事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <!-- 设置注解驱动  @Transactional -->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    
    
    
    <!-- 用于创建 Connection 和管理Connection -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="driverClassName" value="${jdbc.driverClass}"></property>
    </bean>
    
    <!-- 创建SqlSessionFactory，并配置实体对象别名 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="com.neuedu.ssm.po"></property>
        <!-- 指定 Mapper.xml 的 路径  默认如果没有指定则 跟  Mapper。java的路径相同 -->
        <property name="mapperLocations" value="classpath:mapper/*.xml" ></property>
        <property name="configuration" >
            <bean class="org.apache.ibatis.session.Configuration">
                <property name="logImpl" value="org.apache.ibatis.logging.stdout.StdOutImpl"></property>
            </bean>
        
        </property>
    </bean>
    
    <!-- 配置Mapper，自动扫描Mapper接口，并为其注入SqlSessionFactory  在IOC容器中注册  Mapper -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.neuedu.ssm.mapper"></property>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>

</beans>
```

### 生成Mybatis代码

![image-20250318144358471](imgs/image-20250318144358471.png)

![image-20250318144425235](imgs/image-20250318144425235.png)

![image-20250318144518205](imgs/image-20250318144518205.png)



![image-20250318144550523](imgs/image-20250318144550523.png)

生成完之后的代码

![image-20250318144623102](imgs/image-20250318144623102.png)

### 编写 Controller、Service

Controller、Service、Mapper（DAO）   三层架构

```jvaa
package com.neuedu.ssm.controller;

import com.neuedu.ssm.po.Dept;
import com.neuedu.ssm.service.IDeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/1814:33
 */
@RestController
@RequestMapping("/dept")
public class DeptController {

    @Autowired
    private IDeptService deptService;


    @GetMapping("/{id}")
    public Dept getByid(@PathVariable long id){

        return deptService.getById(id);
    }



}
```

```
package com.neuedu.ssm.service;

import com.neuedu.ssm.po.Dept;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/1814:46
 */
public interface IDeptService {
    public Dept getById(long id);
}
```

```
package com.neuedu.ssm.service.impl;

import com.neuedu.ssm.mapper.DeptMapper;
import com.neuedu.ssm.po.Dept;
import com.neuedu.ssm.service.IDeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/1814:47
 */
@Service
public class DeptServiceImpl implements IDeptService {

    @Autowired
    private DeptMapper deptMapper;


    @Override
    public Dept getById(long id) {
        return deptMapper.selectByPrimaryKey(id);
    }
}
```

### 部署测试

http://localhost:8080/ssm/dept/1
![image-20250318145200243](imgs/image-20250318145200243.png)

![image-20250318145220290](imgs/image-20250318145220290.png)

# ssm整合(配置类-纯注解)

- webapp项目
- 添加依赖
  - springmvc
  - spirng  +mybatis
    - aop
    - spring -jdbc
    - mybatis......
  - 单元测试
- 搭建SpringMVC、
  - web.xml-- DispatcherServlet
  - spring-ssm-xml
    - 包扫描
    - 注解驱动
  - Controller
- Mybaits整合
  - 配置文件中配置
    - 数据源
    - SqlSessionFactory
    - Mapper 包扫描（IOC容器中注册   Mapper.java ）
- Service

- 根据ID获取部门  controller-service-mapper

## 创建项目

webapp骨架

com.neuedu.ssm

## 添加依赖 

```xml
<?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>com.neuedu.ssm</groupId>
  <artifactId>springmvc-05-ssm-xml</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc-05-ssm-xml Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  
  
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.version>5.3.39</spring.version>
    <junit.version>5.11.4</junit.version>
    <servlet.version>4.0.1</servlet.version>
  
    <mysql.version>8.0.33</mysql.version>
    <mybatis.version>3.5.19</mybatis.version>
    <mybatis.spring.version>2.0.0</mybatis.spring.version>
    <druid.version>1.2.24</druid.version>
    <jackson.version>2.9.0</jackson.version>
    
    
    
  </properties>
  
  <dependencies>
    <!-- 单元测试库 -->
    <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <!-- spring-webmvc会依赖spring-web  包含 web bean、cort、context、Expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
      <scope>test</scope>
    </dependency>
    
    <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
    <!-- spring-webmvc会依赖spring-web  包含 web bean、cort、context、Expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    
    <!-- jackson相关依赖 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    
    
    
    <!--   在编一个 的时候 需要Servlet jar -->
    <!--   https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>
    
  
    <!-- jdbc、事务的支持 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
  
  
  
  
    <!-- 数据库驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
  
    <!-- 数据库驱动 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
  
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>
  
  
    <!-- Datasource 数据库  Druid  -->
    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>${druid.version}</version>
    </dependency>

  </dependencies>




</project>
```

## 搭建spirngmvc

### 配置  web.xml

- 配置DispatcherServlet



### 配置类

```java
package com.neuedu;

import com.neuedu.ssm.SSMConfigAPP;
import com.neuedu.ssm.WebConfig;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/198:57
 */
public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    /**
     * 返回一个带有@Configuration注解的类。
     * 用来创建整个应用程序的全局Spring容器。
     * 也就是等同于创建applicationContext.xml容器
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[] {SSMConfigAPP.class};
    }

    /**
     * 返回一个带有@Configuration注解的类。
     * 用来创建SpringMVC（即Web相关）的Spring容器。
     * 也就是等同于创建springmvc-servlet.xml容器
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] {WebConfig.class};
    }
    //配置SpringMVC前端控制器映射路径
    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }
}
```

- 加载getServletConfigClasses    用于声明 Servlet 相关的操作（@EnableWebMvc  让Controller 生效）

- 加载getRootConfigClasses  :   加载的是 非Controller（service）

  ```java
  package com.neuedu.ssm;
  
  import com.alibaba.druid.pool.DruidDataSource;
  import org.apache.ibatis.logging.stdout.StdOutImpl;
  import org.apache.ibatis.session.SqlSessionFactory;
  import org.mybatis.spring.SqlSessionFactoryBean;
  import org.mybatis.spring.mapper.MapperScannerConfigurer;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.ComponentScan;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  import org.springframework.transaction.TransactionManager;
  import org.springframework.transaction.annotation.EnableTransactionManagement;
  import org.springframework.transaction.annotation.Transactional;
  import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  
  import javax.sql.DataSource;
  
  /**
   * @author 金山
   * 项目：springmvc-learn
   * site: https://blog.fulfill.com.cn
   * 描述
   * @data 2025/3/198:44
   */
  @Configuration
  @ComponentScan(basePackages = "com.neuedu.ssm")
  @EnableTransactionManagement
  public class SSMConfigAPP {
  
      /**
       * 声明数据源
       * @return
       */
      @Bean
      public DataSource dataSource(){
          DruidDataSource dataSource = new DruidDataSource();
          dataSource.setUrl("jdbc:mysql://localhost:3306/his?useSSL=false");
          dataSource.setDriverClassName("com.mysql.jdbc.Driver");
          dataSource.setUsername("root");
          dataSource.setPassword("root");
  
  
          return dataSource;
      }
  
  
      /**
       * 事务管理器(  spring-tx包  已经写好的 通知)
       * @param dataSource
       * @return
       */
      @Bean
      public TransactionManager  transactionManager(DataSource dataSource){
  
         TransactionManager transactionManager  = new DataSourceTransactionManager(dataSource);
         return  transactionManager;
      }
  
  
  
      /**
       * SqlSessionFactory
       * @param dataSource
       * @return
       * @throws Exception
       */
      @Bean
      public SqlSessionFactory sqlSessionFactory(DataSource dataSource ) throws Exception {
  
          SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
          sqlSessionFactoryBean.setDataSource(dataSource);
          //设置 mybaits的 settingxxxxxx
          org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
          configuration.setLogImpl(StdOutImpl.class);
          sqlSessionFactoryBean.setConfiguration(configuration);
  
          sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
  
  
          return sqlSessionFactoryBean.getObject();
  
      }
  
      /**
       * 扫描 MyBatis中 Mapper的 包，并注册在 IOC容器中
       * @param sqlSessionFactory
       * @return
       */
      @Bean
      public MapperScannerConfigurer mapperSanccer(SqlSessionFactory sqlSessionFactory){
          MapperScannerConfigurer scannerConfigurer = new MapperScannerConfigurer();
  
  
          //创建一堆 Mapper的扫描
  
          scannerConfigurer.setBasePackage("com.neuedu.ssm.mapper");
          scannerConfigurer.setSqlSessionFactory(sqlSessionFactory);
  
          return  scannerConfigurer;
      }
  
  
  
  
  
  }
  ```

```java
package com.neuedu.ssm;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/198:59
 */
@Configuration
@EnableWebMvc    //  Controller
@ComponentScan(basePackages = "com.neuedu.ssm")
public class WebConfig {
}
```





### 从springmvc-05-ssm-xml中将所有java代码粘贴过来



![image-20250319085517024](imgs/image-20250319085517024.png)

### 部署测试

http://localhost:8080/ssm/dept/1
![image-20250318145200243](imgs/image-20250318145200243.png)

![image-20250318145220290](imgs/image-20250318145220290.png)

## MapperScan注解

在配置类中声明下面的注解 代替 @Bean注册Mapper

@MapperScan("com.neuedu.ssm.mapper")

![image-20250319100038756](imgs/image-20250319100038756.png)

## 注解方式读取 jdbc.properties

使用@PropertiSourced读取 属性文件 到 当前类的属性中

```java
package com.neuedu.ssm;

import com.alibaba.druid.pool.DruidDataSource;
import com.neuedu.ssm.annotation.MyAnnotation;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

import javax.sql.DataSource;

/**
 * @author 金山
 * 项目：springmvc-learn
 * site: https://blog.fulfill.com.cn
 * 描述
 * @data 2025/3/198:44
 */
@Configuration
@ComponentScan(basePackages = "com.neuedu.ssm")
@MapperScan("com.neuedu.ssm.mapper")
@EnableTransactionManagement
@PropertySource("classpath:jdbc.properties")
public class SSMConfigAPP {


    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driverClass}")
    private String driverClass;


    /**
     * 声明数据源
     * @return
     */
    // @Bean
    // public DataSource dataSource(){
    //     DruidDataSource dataSource = new DruidDataSource();
    //     dataSource.setUrl("jdbc:mysql://localhost:3306/his?useSSL=false");
    //     dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    //     dataSource.setUsername("root");
    //     dataSource.setPassword("root");
    //
    //
    //     return dataSource;
    // }

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClass);
        dataSource.setUsername(username);
        dataSource.setPassword(password);


        return dataSource;
    }


    /**
     * 事务管理器(  spring-tx包  已经写好的 通知)
     * @param dataSource
     * @return
     */
    @Bean
    public TransactionManager  transactionManager(DataSource dataSource){

       TransactionManager transactionManager  = new DataSourceTransactionManager(dataSource);
       return  transactionManager;
    }



    /**
     * SqlSessionFactory
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource ) throws Exception {

        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        //设置 mybaits的 settingxxxxxx
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setLogImpl(StdOutImpl.class);
        sqlSessionFactoryBean.setConfiguration(configuration);

        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));


        return sqlSessionFactoryBean.getObject();

    }

    // /**
    //  * 扫描 MyBatis中 Mapper的 包，并注册在 IOC容器中
    //  * @param sqlSessionFactory
    //  * @return
    //  */
    // @Bean
    // public MapperScannerConfigurer mapperSanccer(SqlSessionFactory sqlSessionFactory){
    //     MapperScannerConfigurer scannerConfigurer = new MapperScannerConfigurer();
    //
    //
    //     //创建一堆 Mapper的扫描
    //
    //     scannerConfigurer.setBasePackage("com.neuedu.ssm.mapper");
    //     scannerConfigurer.setSqlSessionFactory(sqlSessionFactory);
    //
    //     return  scannerConfigurer;
    // }





}
```

# CRUD 测试

## Dept

DeptMapper。xml

DeptMapper.java 

添加了一个 selectList的方法

## 编写Service

IDeptService 接口和 DeptServiceImpl 实现类

## DeptController

### 查询集合

```
@GetMapping("/list")
public List<Dept> list(){

    return deptService.list();
}
```





APIfox  邀请

狐友K4d9 在 Apifox 邀请你加入团队 个人团队 https://app.apifox.com/invite?token=CqwCXUzmMBjmWH04cbPgS

![image-20250319112701879](imgs/image-20250319112701879.png)