Spring框架汇总

Spring框架概述

单独列出状态的是重点区域

Spring框架是一个广泛使用的Java企业级开发框架，其体系结构由多个模块组成，每个模块都有其特定的功能和作用。

1. 核心容器（Core Container）

核心容器提供了Spring的基本功能，是其他模块建立的基础，主要由Beans模块、Core模块、Context模块和Spring EL模块组成，介绍如下：

Beans模块：提供了BeanFactory，是工厂模式实现的经典，Spring将管理对象称为Bean。

Core核心模块：提供了Spring框架的基本组成部分，包括IoC和DI功能。
Context上下文模块：构建于核心模块之上，它是访问定义配置的任何对象的媒介，扩展了BeanFactory的功能，其中ApplicationContext是Context模块的核心接口。
Spring EL模块：是Spring 3.0后新增的模块，提供了Spring表达式语言支持，是运行时查询和操作对象图的强大的表达式语言。

2. 数据访问/集成层（Data Access/Integration）

数据访问/集成层包括JDBC、ORM、OXM、JMS和Transactions模块，介绍如下：

JDBC模块：提供了一个JDBC的抽象层，大幅度地减少了在开发中对数据库的操作的编码。

ORM模块：提供了与多个第三方持久层框架的良好整合。
OXM模块：提供了一个支持对象/XML映射的抽象层实现，如JAXB、Castor、XMLBeans、JiBX和XStream。
JMS模块：指Java消息传递服务，包含使用和产生消息的特性，自Spring 4.1版本以后，提供了与Spring-messaging模块的集成。
Transactions模块：支持对实现特殊接口以及所有POJO类的编程和声明式的事务管理。

3. Web层（Web）

Web层包括WebSocket、Servlet、Web和Portlet模块，介绍如下：

Web模块：提供了基础的针对Web开发的集成特性，例如多方文件上传，利用Servlet监听器进行IoC容器初始化以及Web应用上下文。
Servlet模块：也称做Spring-webmvc模块，包含Spring的模型-视图-控制器（MVC）和REST Web Services实现的Web应用程序。
WebSocket模块：Spring 4.0以后新增功能，提供了WebSocket和SockJS的实现，以及对STOMP的支持。
Portlet模块：类似Servlet模块的功能，提供了Portlet环境下的MVC实现。

4. 其他模块（Other Modules）

Spring的其他模块还有AOP、Aspects、Instrumentation、Messaging以及Test模块，介绍如下：

AOP模块：提供了面向方面编程的支持，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。

Aspects模块：提供了与AspectJ的集成功能，Aspect是一个功能强大且成熟的面向方面编程的框架。
Instrumentation模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
Messaging模块：Spring 4.0以后新增的模块，提供了对消息传递体系结构和协议的支持。
Test模块：提供了对单元测试和集成测试的支持。

spring的核心机制:依赖注入/控制反转

什么是IoC（控制反转）？

IoC（Inversion of Control，控制反转）是一种设计原则，它将对象的创建和管理的控制权从应用程序代码转移到框架或容器中。这样，容器负责对象的生命周期管理，使得代码更加灵活和可测试。

如何实现控制反转？

控制反转主要通过以下两种方式实现：

依赖注入（Dependency Injection，DI）：
- 通过将对象的依赖关系在运行时注入到对象中，而不是在对象内部创建依赖。可以通过构造函数、属性或方法实现。
服务定位器（Service Locator）：
- 提供一个集中式的注册表来查找和获取服务（对象）。虽然实现了控制反转，但通常不如依赖注入灵活，因为仍需显式请求服务。

什么是依赖注入？

依赖注入是一种设计模式，允许在运行时将对象的依赖关系注入到对象中，而不是在对象内部创建这些依赖。这种方式降低了对象之间的耦合，提高了代码的可测试性和可维护性。
好的，下面我们以AdminInfo类为例，讲解依赖注入的几种主要类型。

依赖注入的类型

依赖注入主要有三种类型：构造函数注入、属性注入和方法注入。我们将分别通过AdminInfo类的例子来说明这三种类型。

1. 构造函数注入

构造函数注入是通过类的构造函数将依赖对象传递给目标对象。在创建对象时，依赖关系在构造时就被注入。

示例代码：

package com.ssm.entity;

public class AdminInfo {
    private int id;
    private String name;
    private String pwd;

    // 默认构造函数
    public AdminInfo() {
    }

    // 带参数的构造函数
    public AdminInfo(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    // 打印方法
    public void print() {
        System.out.println(id + "--" + name + " -- " + pwd);
    }
}

package com.ssm.service;

import com.ssm.entity.AdminInfo;

public class AdminService {
    private AdminInfo adminInfo;

    // 通过构造函数注入AdminInfo
    public AdminService(AdminInfo adminInfo) {
        this.adminInfo = adminInfo;
    }

    public void displayAdminInfo() {
        adminInfo.print();
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        AdminInfo admin = new AdminInfo("admin", "password");
        AdminService service = new AdminService(admin); // 依赖注入
        service.displayAdminInfo(); // 输出: 0--admin -- password
    }
}

2. 属性注入

属性注入是通过公共属性或setter方法将依赖对象注入到目标对象中。这种方式在对象创建后，可以随时修改依赖关系。

示例代码：

package com.ssm.entity;

public class AdminInfo {
    private int id;
    private String name;
    private String pwd;

    // 默认构造函数
    public AdminInfo() {
    }

    // 带参数的构造函数
    public AdminInfo(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    // 打印方法
    public void print() {
        System.out.println(id + "--" + name + " -- " + pwd);
    }
}

package com.ssm.service;

import com.ssm.entity.AdminInfo;

public class AdminService {
    private AdminInfo adminInfo;

    // Setter方法进行属性注入
    public void setAdminInfo(AdminInfo adminInfo) {
        this.adminInfo = adminInfo;
    }

    public void displayAdminInfo() {
        adminInfo.print();
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        AdminInfo admin = new AdminInfo("admin", "password");
        AdminService service = new AdminService();
        service.setAdminInfo(admin); // 通过setter方法注入
        service.displayAdminInfo(); // 输出: 0--admin -- password
    }
}

3. 方法注入

方法注入是通过方法参数将依赖对象传递给目标对象的方法。这种方式适用于需要在特定方法中使用依赖的情况。

示例代码：

package com.ssm.entity;

public class AdminInfo {
    private int id;
    private String name;
    private String pwd;

    // 默认构造函数
    public AdminInfo() {
    }

    // 带参数的构造函数
    public AdminInfo(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    // 打印方法
    public void print() {
        System.out.println(id + "--" + name + " -- " + pwd);
    }
}

package com.ssm.service;

import com.ssm.entity.AdminInfo;

public class AdminService {
    public void displayAdminInfo(AdminInfo adminInfo) {
        adminInfo.print();
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        AdminInfo admin = new AdminInfo("admin", "password");
        AdminService service = new AdminService();
        service.displayAdminInfo(admin); // 输出: 0--admin -- password
    }
}

构造函数注入：在对象创建时通过构造函数传入依赖，适合于必须依赖的情况。
属性注入：通过setter方法注入依赖，适合于可选依赖或需要在对象创建后修改依赖的情况。
方法注入：通过方法参数传入依赖，适合于在特定方法中使用依赖的情况。

Spring Bean的装配

在Java Web应用中，ContextLoaderListener和ContextLoaderServlet是两种常用的载入方式，用于初始化Spring应用上下文。

1. ContextLoaderListener

ContextLoaderListener是一个ServletContextListener，用于在Web应用启动时加载Spring的应用上下文。它通常用于加载根应用上下文，适合于整个应用共享的Bean。

配置示例：

在web.xml中配置ContextLoaderListener：

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         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_3_1.xsd"
         version="3.1">

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>

    <!-- 其他配置 -->
</web-app>

使用示例：

在applicationContext.xml中定义Bean：

<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <bean id="myBean" class="com.example.MyBean" />
    <!-- 其他Bean定义 -->
</beans>

2. ContextLoaderServlet

ContextLoaderServlet是一个Servlet，用于加载Spring的Web应用上下文。它通常用于处理特定的请求，并可以与Spring MVC结合使用。

配置示例：

在web.xml中配置ContextLoaderServlet：

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         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_3_1.xsd"
         version="3.1">

    <servlet>
        <servlet-name>springDispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springDispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring-servlet.xml</param-value>
    </context-param>

    <!-- 其他配置 -->
</web-app>

使用示例：

在spring-servlet.xml中定义Bean：

<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <bean id="myController" class="com.example.MyController" />
    <!-- 其他Bean定义 -->
</beans>

ContextLoaderListener：用于加载根应用上下文，适合于整个应用共享的Bean。
ContextLoaderServlet：用于加载Web应用上下文，通常与Spring MVC结合使用，处理特定请求。

以下是基于注解的Bean装配中常用的六个注解的简单介绍：

1. `@Component`

作用：标识一个类为Spring的组件，Spring会自动扫描并注册为Bean。
使用场景：用于任何Spring管理的组件，通常用于通用的类。

2. `@Repository`

作用：标识一个类为数据访问层的组件，通常用于持久化操作。
使用场景：用于DAO（数据访问对象）类，Spring会为其提供异常转换等功能。

3. `@Service`

作用：标识一个类为服务层的组件，通常用于业务逻辑处理。
使用场景：用于Service类，表示该类包含业务逻辑。

4. `@Controller`

作用：标识一个类为控制层的组件，通常用于处理请求。
使用场景：用于Spring MVC中的控制器类，负责接收和处理用户请求。

5. `@Autowired`

作用：用于自动注入Spring容器中的Bean。
使用场景：可以用于构造函数、属性或方法上，Spring会根据类型自动注入相应的Bean。

6. `@Resource`

作用：用于按名称自动注入Bean。
使用场景：可以用于属性上，Spring会根据Bean的名称进行注入，通常用于与JNDI结合使用。

Spring ADP

OOP（面向对象编程）

定义：一种编程范式，通过“对象”来组织代码，强调数据和方法的封装。
特点：封装、继承和多态。
应用：适用于构建复杂系统，通过对象之间的交互实现功能。

AOP（面向切面编程）

定义：一种编程范式，关注横切关注点（如日志、事务等），通过切面来增强模块功能。
特点：切面、切入点、通知和织入。
应用：用于处理跨多个模块的关注点，提高代码的可维护性。

AOP的常用术语:
好的，以下是AOP的常用术语及其英文单词：

切面（Aspect）
连接点（Join Point）
切入点（Pointcut）
通知（Advice
目标对象（Target Object）
代理对象（Proxy Object）
织入（Weaving）

Xml注解：通知-给一段代码问是什么通知?

返回通知：myAfterReturnAdvice
异常通知：MyThrowingAdvice
环绕通知：myAroundAdvice
前置通知：browse
后置通知：After
这些通知分别对应于AOP中的不同切面行为。

Spring的数据库的编程

当然可以，以下是一个使用XML配置Spring JDBC数据源的示例：

<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <!-- 配置驱动 -->
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/> <!-- 配置地址 -->
        <property name="username" value="root"/> <!-- 配置用户名 -->
        <property name="password" value="password"/> <!-- 配置密码 -->
    </bean>

    <!-- 其他Bean配置 -->
</beans>

Spring MVC简介

配置说明：

driverClassName：配置数据库驱动类。
url：配置数据库连接地址。
username：配置数据库用户名。
password：配置数据库密码。

这个XML配置示例展示了如何在Spring中设置JDBC数据源。
好的，以下是关于Spring MVC的简介：

1. MVC这三个字母代表什么

M：Model（模型） - 代表应用程序的数据和业务逻辑。
V：View（视图） - 代表用户界面，负责展示数据。
C：Controller（控制器） - 处理用户请求，协调模型和视图之间的交互。

2. 配置文件springmvc.xml

springmvc.xml是Spring MVC的配置文件，通常包含以下内容：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/mvc 
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 启用Spring MVC注解 -->
    <mvc:annotation-driven/>

    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 其他Bean配置 -->
</beans>

3. Spring MVC的请求流程

Spring MVC的请求流程通常包括以下几个步骤：

请求到达DispatcherServlet：用户发送请求，首先到达前端控制器DispatcherServlet。
请求映射：DispatcherServlet根据请求URL查找对应的处理器（Controller）。
调用处理器：找到对应的Controller后，调用其处理方法。
返回模型和视图：Controller处理完请求后，返回模型数据和视图名称。
视图解析（看上方代码要考）：DispatcherServlet使用视图解析器将视图名称解析为具体的视图。
渲染视图：最终，视图被渲染并返回给用户。

一句话就是请求到达，请求映射，调用处理器，返回模型，视图解析，渲染视图
@RequestMapping 是 Spring MVC 中用于处理请求的注解，主要用于将 HTTP 请求映射到特定的处理方法或类上。以下是关于 @RequestMapping 的一些关键点：

Spring MVC注解 @RequestMapping

1. 基本用法

类级别：可以在控制器类上使用，表示该类中的所有请求处理方法的公共路径前缀。
方法级别：可以在具体的方法上使用，表示该方法处理的特定请求。

2. 示例代码

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

@Controller
@RequestMapping("/user") // 类级别的请求映射
public class UserController {

    @RequestMapping(value = "/get", method = RequestMethod.GET) // 方法级别的请求映射
    @ResponseBody
    public String getUser() {
        return "获取用户信息";
    }

    @RequestMapping(value = "/create", method = RequestMethod.POST) // 方法级别的请求映射
    @ResponseBody
    public String createUser() {
        return "创建用户成功";
    }
}

@RequestMapping 是 Spring MVC 中非常重要的注解，用于定义请求的路由和处理逻辑。
Spring MVC 标签库主要用于在 JSP 页面中简化与 Spring MVC 的集成，提供了一些方便的标签来处理表单、URL、消息等。以下是一些常用的 Spring MVC 标签库及其功能：

Spring MVC 标签库

1. 引入标签库

在 JSP 页面中使用 Spring MVC 标签库之前，需要引入相关的标签库：
（引库可以不用看）

1 2	<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %> <%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>

2. 常用标签

1. `<form:form>`

用于创建表单，自动绑定表单数据到模型对象。

示例：

<form:form modelAttribute="user" action="create" method="post">
    <form:input path="username" />
    <form:input path="password" type="password" />
    <input type="submit" value="提交" />
</form:form>

2. `<form:input>`

用于创建输入框，绑定到模型属性。
示例：
1
<form:input path="email" />

3. `<form:select>`

用于创建下拉选择框，绑定到模型属性。

示例：

<form:select path="gender">
    <form:option value="male">男</form:option>
    <form:option value="female">女</form:option>
</form:select>

4. `<form:checkbox>`

用于创建复选框，绑定到模型属性。

示例：

1	<form:checkbox path="subscribe" /> 订阅新闻

5. `<form:errors>`

用于显示表单验证错误信息。

示例：

1	<form:errors path="username" cssClass="error" />

类型转换，数抗脆式化和数据校验

1. 类型转换

类型转换是将请求参数转换为控制器方法所需的Java类型的过程。Spring MVC提供了自动类型转换的功能。

使用示例：

@RequestMapping("/submit")
public String submit(@RequestParam("age") int age) {
    // age参数会自动转换为int类型
    return "success";
}

自定义类型转换：可以通过实现Converter接口来自定义类型转换。

public class StringToUserConverter implements Converter<String, User> {
    @Override
    public User convert(String source) {
        // 自定义转换逻辑
        return new User(source);
    }
}

2. 数据格式化

数据格式化用于将对象属性格式化为字符串，或将字符串解析为对象属性。Spring提供了@InitBinder注解来注册自定义的格式化器。

使用示例：

@InitBinder
public void initBinder(WebDataBinder binder) {
    binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
}

自定义格式化：可以实现PropertyEditor接口或使用@InitBinder来注册格式化器。

3. 数据校验

数据校验用于验证用户输入的数据是否符合预期的格式或规则。Spring MVC支持JSR-303（Bean Validation）规范。

使用示例：

public class User {
    @NotNull
    private String username;

    @Min(18)
    private int age;
}

@PostMapping("/register")
public String register(@Valid @ModelAttribute User user, BindingResult result) {
    if (result.hasErrors()) {
        return "registerForm";
    }
    // 处理注册逻辑
    return "success";
}

SpringMVC 的文件上传和下载

1. Spring MVC 文件上传的作用与配置

1.1 配置文件扫描

在Spring配置文件中，需要启用文件上传的支持，通常通过MultipartResolver来实现。可以使用CommonsMultipartResolver或StandardServletMultipartResolver。

1
2
3

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="10485760"/> <!-- 设置最大上传文件大小 -->
</bean>

1.2 文件解析类

CommonsMultipartResolver是基于Apache Commons FileUpload库的实现，负责解析上传的文件。它会将上传的文件封装为MultipartFile对象，方便后续处理。

2. 上传文件的主要代码

在控制器中处理文件上传时，通常会使用MultipartFile对象。以下是一个简单的文件上传示例代码：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@RestController
public class FileUploadController {

    @PostMapping("/upload")
    public String handleFileUpload(@RequestParam("file") MultipartFile file) {
        if (!file.isEmpty()) {
            try {
                // 指定文件保存路径
                File destinationFile = new File("/path/to/upload/directory/" + file.getOriginalFilename());
                // 将上传的文件保存到指定路径
                file.transferTo(destinationFile);
                return "文件上传成功：" + destinationFile.getAbsolutePath();
            } catch (IOException e) {
                e.printStackTrace();
                return "文件上传失败：" + e.getMessage();
            }
        } else {
            return "上传的文件为空";
        }
    }
}

代码说明：

**@RequestParam("file") MultipartFile file**：接收上传的文件。
**file.transferTo(destinationFile)**：将上传的文件保存到指定的路径。
在Spring MVC中，国际化和拦截器是两个重要的功能模块，分别用于处理多语言支持和请求的拦截与处理。以下是对这两个功能的详细介绍：

SpingMVC的国际化和拦截器

1. Spring MVC的国际化

国际化（i18n）是指支持多种语言和地区的功能。Spring MVC通过MessageSource接口和相关配置来实现国际化。

1.1 配置国际化支持

在Spring配置文件中，需要配置MessageSource，通常使用ResourceBundleMessageSource来加载消息资源文件。

1
2
3

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
    <property name="basename" value="messages"/> <!-- 指定资源文件的基础名称 -->
</bean>

1.2 创建消息资源文件

在项目的src/main/resources目录下创建messages.properties、messages_zh.properties、messages_en.properties等文件，分别用于不同语言的消息。

messages.properties（默认语言）

1	greeting=Hello

messages_zh.properties（中文）

1	greeting=你好

1.3 使用国际化消息

在控制器或视图中使用MessageSource来获取国际化消息。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    @Autowired
    private MessageSource messageSource;

    @GetMapping("/greeting")
    public String greeting(@RequestHeader(name = "Accept-Language", required = false) String locale) {
        return messageSource.getMessage("greeting", null, locale);
    }
}

2. Spring MVC的拦截器

拦截器用于在请求到达控制器之前或响应返回之前进行处理，常用于日志记录、权限检查等。

2.1 创建拦截器

实现HandlerInterceptor接口，重写相应的方法。

import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在请求处理之前执行
        System.out.println("请求路径: " + request.getRequestURI());
        return true; // 返回true表示继续处理请求，返回false则终止请求
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 在请求处理之后执行
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 在整个请求完成之后执行
    }
}

2.2 配置拦截器（拦截器配置代码要考）

在Spring配置文件中配置拦截器。

1
2
3

<mvc:interceptors>
    <bean class="com.example.MyInterceptor"/>
</mvc:interceptors>

或者在Java配置中使用WebMvcConfigurer接口：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**"); // 拦截所有请求
    }
}

MyBatis 是一个持久层框架，主要用于简化数据库操作。以下是关于 MyBatis 中 SQL 语句的基本用法，包括插入、查询、更新和删除操作，以及映射的相关内容。

Mybatis

1. SQL 语句

1.1 根据 ID 查询词数据

使用 <select> 标签来查询数据。

1
2
3

<select id="selectWordById" parameterType="int" resultType="Word">
    SELECT * FROM words WHERE id = #{id}
</select>

id：查询的唯一标识符。
parameterType：输入参数的类型。
resultType：返回结果的类型。

1.2 新增一条数据

使用 <insert> 标签来插入数据。

1
2
3

<insert id="insertWord" parameterType="Word">
    INSERT INTO words (word, definition) VALUES (#{word}, #{definition})
</insert>

parameterType：传入的对象类型，通常是一个 Java Bean。

1.3 修改数据

使用 <update> 标签来更新数据。

1
2
3

<update id="updateWord" parameterType="Word">
    UPDATE words SET definition = #{definition} WHERE id = #{id}
</update>

1.4 删除数据

使用 <delete> 标签来删除数据。

1
2
3

<delete id="deleteWord" parameterType="int">
    DELETE FROM words WHERE id = #{id}
</delete>

2. 映射

p166配置映射

<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mybatis.mapper.UserInfoMapper">

    <!-- 根据用户编号获取用户信息 -->
    <select id="findUserInfoById" parameterType="int" resultMap="userInfoMap">
        SELECT *
        FROM user_info WHERE id = #{id}
    </select>

    <resultMap type="UserInfo" id="userInfoMap">
        <id property="uid" column="id" />
        <result property="uname" column="userName"/>
        <result property="upass" column="password"/>
    </resultMap>
</mapper>

关联映射

1. 一对一映射

定义：一个对象对应一个对象。
例子：一个用户有一个个人资料。

2. 一对多映射

定义：一个对象对应多个对象。
例子：一个用户可以有多个订单。

3. 多对多映射

定义：多个对象可以对应多个对象。
例子：一个用户可以有多个角色，而一个角色也可以被多个用户拥有。

总结

一对一：一对一。
一对多：一对多。
多对多：多对多。
这样好记多了吧。

动态SQL

动态 SQL 是指在 SQL 查询中根据条件动态生成不同的 SQL 语句。在 MyBatis 中，可以使用 <if>、<where> 和 <set> 标签来实现动态 SQL。

1. `<if>` 标签

功能：根据条件判断是否生成某个 SQL 片段。

使用方法：

在 <if> 标签中，可以使用 test 属性来指定条件表达式。
如果条件为 true，则生成 <if> 标签内的 SQL 片段。

示例：

<select id="findUsers" parameterType="User">
    SELECT * FROM users
    <where>
        <if test="userName != null">
            AND userName = #{userName}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
    </where>
</select>

在这个示例中，如果 userName 或 age 不为 null，则相应的条件会被添加到 SQL 查询中。

2. `<where>` 标签

功能：自动处理 SQL 查询中的 WHERE 子句，避免手动添加 AND 或 OR。

使用方法：

<where> 标签会自动在生成的 SQL 语句前添加 “WHERE” 关键字，并在第一个条件前自动添加 “AND” 或 “OR”。

示例：

<select id="findUsers" parameterType="User">
    SELECT * FROM users
    <where>
        <if test="userName != null">
            userName = #{userName}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
    </where>
</select>

在这个示例中，如果 userName 不为 null，WHERE 后面会直接跟上 userName = #{userName}，如果 age 不为 null，AND age = #{age} 会被添加。

3. `<set>` 标签

功能：用于动态生成 UPDATE 语句中的 SET 子句。

使用方法：

<set> 标签会自动处理 SET 子句中的逗号，避免手动添加。

示例：

<update id="updateUser" parameterType="User">
    UPDATE users
    <set>
        <if test="userName != null">
            userName = #{userName},
        </if>
        <if test="age != null">
            age = #{age},
        </if>
    </set>
    WHERE id = #{id}
</update>

在这个示例中，如果 userName 或 age 不为 null，相应的字段会被更新，并且逗号会自动处理。
总结如下

**<if>**：根据条件生成 SQL 片段。
**<where>**：自动处理 WHERE 子句。
**<set>**：自动处理 UPDATE 语句中的 SET 子句。

Spring整合MyBaits

这部分建议直接看书得了p222~223xml配置
p22应用

Spring框架汇总

Spring框架概述

1. 核心容器（Core Container）

2. 数据访问/集成层（Data Access/Integration）

3. Web层（Web）

4. 其他模块（Other Modules）

spring的核心机制:依赖注入/控制反转

什么是IoC（控制反转）？

什么是依赖注入？

依赖注入的类型

1. 构造函数注入

2. 属性注入

3. 方法注入

Spring Bean的装配

1. ContextLoaderListener

2. ContextLoaderServlet

1. @Component

2. @Repository

3. @Service

4. @Controller

5. @Autowired

6. @Resource

Spring ADP

OOP（面向对象编程）

AOP（面向切面编程）

Xml注解：通知-给一段代码问是什么通知?

Spring的数据库的编程

Spring MVC简介

配置说明：

1. MVC这三个字母代表什么

2. 配置文件springmvc.xml

3. Spring MVC的请求流程

Spring MVC注解 @RequestMapping

1. 基本用法

2. 示例代码

Spring MVC 标签库

1. 引入标签库

2. 常用标签

1. <form:form>

2. <form:input>

3. <form:select>

4. <form:checkbox>

5. <form:errors>

类型转换，数抗脆式化和数据校验

1. 类型转换

2. 数据格式化

3. 数据校验

SpringMVC 的文件上传和下载

1. Spring MVC 文件上传的作用与配置

1.1 配置文件扫描

1.2 文件解析类

2. 上传文件的主要代码

SpingMVC的国际化和拦截器

1. Spring MVC的国际化

1.1 配置国际化支持

1.2 创建消息资源文件

1.3 使用国际化消息

2. Spring MVC的拦截器

2.1 创建拦截器

2.2 配置拦截器（拦截器配置代码要考）

Mybatis

1. SQL 语句

1.1 根据 ID 查询词数据

1.2 新增一条数据

1.3 修改数据

1.4 删除数据

2. 映射

关联映射

1. 一对一映射

2. 一对多映射

3. 多对多映射

总结

动态SQL

1. <if> 标签

2. <where> 标签

3. <set> 标签

Spring整合MyBaits

1. `@Component`

2. `@Repository`

3. `@Service`

4. `@Controller`

5. `@Autowired`

6. `@Resource`

1. `<form:form>`

2. `<form:input>`

3. `<form:select>`

4. `<form:checkbox>`

5. `<form:errors>`

1. `<if>` 标签

2. `<where>` 标签

3. `<set>` 标签