【问题来源】重庆银行【问题简要】IVR播报金额为十亿时，例如1635635958，只播报了前两位就不播了【AICC解决方案版本】AICC 23.200.0【期望解决时间】尽快【问题现象描述】IVR播报金额为十亿时，例如1635635958，只播报了前两位就不播了【日志或错误截图】【附件】无

【问题来源】【必填】南网电网【问题简要】【必填】语音平台是否有对全部技能队列的一个当前排队数查询的接口支持，或者是平台数据库能实时统计出来的库表【问题类别】【必填】CC-Gateway【AICC解决方案版本】【必填】AICC 24.200.0【期望解决时间】【选填】尽快【问题现象描述】【必填】语音平台是否有对全部技能队列的一个当前排队数查询的接口支持，或者是平台数据库能实时统计出来的库表【日志或错误截图】【可选】【附件】【可选】无

package com.xuecheng.media;import com.j256.simplemagic.ContentInfo;import com.j256.simplemagic.ContentInfoUtil;import io.minio.*;import io.minio.errors.*;import org.apache.commons.codec.digest.DigestUtils;import org.apache.commons.io.IOUtils;import org.junit.jupiter.api.Test;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.http.MediaType;import java.io.*;import java.util.HashMap;import java.util.Map;/** * 测试minio的sdk * * @author ManolinCoder * @date 2024-10-21 */@SpringBootTestpublic class MinioTest { // MinIO服务器地址 String url = "http://localhost:9000"; // MinIO访问密钥 String accessKey = "accessKey"; // MinIO秘密密钥 String secretKey = "secretKey"; // 待上传的文件路径 String filePath = "/Users/lcm/Movies/测试视频/1.mp4"; // MinIO存储桶名称 String bucketName = "testbucket"; // 存储桶中的对象名称 String objectName = "1.mp4"; MinioClient minioClient = MinioClient.builder().endpoint(url).credentials(accessKey, secretKey).build(); /** * 上传文件 * * @param * @return void * @author ManolinCoder * @date 2024-10-21 */ @Test public void testUpload() throws Exception { ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(".mp4"); String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE; // 通用 mimeType 字节流 if (extensionMatch != null) { mimeType = extensionMatch.getMimeType(); } try { // Make 'asiatrip' bucket if not exist. boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket("testbucket").build()); if (!found) { // Make a new bucket called 'asiatrip'. minioClient.makeBucket(MakeBucketArgs.builder().bucket("testbucket").build()); } else { System.out.println("文件桶已存在！！！"); } // 上传文件 uploadFile(minioClient, filePath, bucketName, objectName, mimeType); //上传文件完整性校验 boolean flag = checkFileIntegrity(minioClient, filePath, bucketName, objectName); System.out.println(flag ? "上传文件成功了！！！" : "上传文件失败了！！！"); } catch (MinioException e) { System.out.println("Error occurred: " + e); System.out.println("HTTP trace: " + e.httpTrace()); } } /** * 删除文件 * * @param * @return void * @author ManolinCoder * @date 2024-10-21 */ @Test public void testDelete() throws Exception { RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket("testbucket").object("1.MP4").build(); minioClient.removeObject(removeObjectArgs); } /** * 查询文件，下载到本地 * * @param * @return void * @author ManolinCoder * @date 2024-10-21 */ @Test public void testGetObject() throws Exception { GetObjectArgs getObjectArgs = GetObjectArgs.builder().bucket("testbucket").object("1.MP4").build(); FilterInputStream inputStream = minioClient.getObject(getObjectArgs); String localFileName = "/Users/lcm/Downloads/1.mp4"; // 指定输出流 FileOutputStream outputStream = new FileOutputStream(new File(localFileName)); IOUtils.copy(inputStream, outputStream); // md5完整性校验 boolean flag = checkFileIntegrity(minioClient, localFileName, bucketName, objectName); if (flag) { System.out.println("下载成功了！！！"); } else { System.out.println("下载失败了！！！"); } } /** * 上传文件 * * @param minioClient * @param filePath * @param bucketName * @param objectName * @param contentType * @return void * @author CoderManolin * @date 2024-10-25 */ public void uploadFile(MinioClient minioClient, String filePath, String bucketName, String objectName, String contentType) throws Exception { // 计算上传前本地文件MD5 String uploadLocalFileMD5 = calculateMD5(filePath); System.out.println("上传前本地文件MD5: uploadLocalFileMD5=" + uploadLocalFileMD5); Map<String, String> md5Map = new HashMap<>(); md5Map.put("md5", uploadLocalFileMD5); //上传文件到 MinIO File file = new File(filePath); minioClient.putObject( PutObjectArgs.builder() .bucket(bucketName) .object(objectName) .stream(new FileInputStream(file), file.length(), -1) .userMetadata(md5Map) .contentType(contentType) .build() ); System.out.println("File uploaded successfully: " + objectName); } /** * 计算md5 * * @param filePath * @return File * @author ManolinCoder * @date 2024-10-23 */ public String calculateMD5(String filePath) throws Exception { FileInputStream fileInputStream = new FileInputStream(filePath); return DigestUtils.md5Hex(fileInputStream); } /** * 对比本地文件和minio文件的MD5值是否一致，校验文件完整性 * * @param minioClient * @param filePath * @param bucketName * @param objectName * @return boolean * @author CoderManolin * @date 2024-10-25 */ public boolean checkFileIntegrity(MinioClient minioClient, String filePath, String bucketName, String objectName) throws Exception { // 计算本地文件的MD5 String localFileMD5 = calculateMD5(filePath); System.out.println("Local file MD5: " + localFileMD5); // 获取MinIO中对象的MD5 StatObjectResponse stat = minioClient.statObject( StatObjectArgs.builder() .bucket(bucketName) .object(objectName) .build()); String minioFileMD5 = stat.userMetadata().get("md5"); System.out.println("MinIO file MD5: " + minioFileMD5); // 比较MD5值 return localFileMD5.equals(minioFileMD5); }}

使用EasyExcel进行大数据量导出时容易导致内存溢出，特别是在导出百万级别的数据时。你有遇到过这种情况吗，以下是V 哥整理的解决该问题的一些常见方法，分享给大家，欢迎一起讨论：EasyExcel大数据量导出常见方法1. 分批写入EasyExcel支持分批写入数据，可以将数据分批加载到内存中，分批写入Excel文件，避免一次性将大量数据加载到内存中。示例代码： String fileName = "large_data.xlsx"; ExcelWriter excelWriter = EasyExcel.write(fileName).build(); WriteSheet writeSheet = EasyExcel.writerSheet("Sheet1").build(); // 假设每次写入10000条数据 int batchSize = 10000; List<Data> dataList; int pageIndex = 0; do { // 分页获取数据 dataList = getDataByPage(pageIndex++, batchSize); excelWriter.write(dataList, writeSheet); } while (dataList.size() == batchSize); // 关闭资源 excelWriter.finish();2. 设置合适的JVM内存针对大数据导出场景，可以尝试增大JVM的内存分配，例如： java -Xms512M -Xmx4G -jar yourApp.jar解释：-Xms512M：设置初始堆大小为512MB。-Xmx4G：设置最大堆大小为4GB。3. 减少数据对象的复杂性导出数据时，尽量简化数据对象，避免不必要的嵌套和多余字段的加载，以减少对象占用的内存空间。4. 关闭自动列宽设置EasyExcel的自动列宽功能会占用大量内存，特别是在数据量较大的情况下。关闭自动列宽可以节省内存。示例代码： EasyExcel.write(fileName) .registerWriteHandler(new SimpleWriteHandler()) // 不使用自动列宽 .sheet("Sheet1") .doWrite(dataList);5. 使用Stream导出（适合大数据）利用OutputStream分批写入数据，减少内存消耗。通过BufferedOutputStream可以进一步提高性能。示例代码： try (OutputStream out = new BufferedOutputStream(new FileOutputStream(fileName))) { ExcelWriter excelWriter = EasyExcel.write(out).build(); WriteSheet writeSheet = EasyExcel.writerSheet("Sheet1").build(); int pageIndex = 0; List<Data> dataList; do { dataList = getDataByPage(pageIndex++, batchSize); excelWriter.write(dataList, writeSheet); } while (dataList.size() == batchSize); excelWriter.finish(); } catch (IOException e) { e.printStackTrace(); }6. 选择合适的数据导出工具如果数据量非常大，可以考虑切换到支持更高性能的导出工具（如Apache POI的SXSSFWorkbook），适合导出百万级别数据量，但配置和使用会更复杂。亮点来了，那要如何使用 POI 的 SXSSFWorkbook来导出百万级别的数据量呢？Apache POI的SXSSFWorkbook 实现百万级别数据量的导出案例使用Apache POI的SXSSFWorkbook可以处理大数据量的Excel导出，因为SXSSFWorkbook基于流式写入，不会将所有数据加载到内存中，而是使用临时文件进行缓存，这样可以显著减少内存消耗，适合百万级别数据的导出。下面我们来看一个完整的实现示例。代码如下import org.apache.poi.ss.usermodel.*; import org.apache.poi.xssf.streaming.SXSSFWorkbook; import java.io.FileOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.List; public class LargeDataExportExample { public static void main(String[] args) { // 文件输出路径 String filePath = "vg_large_data_export.xlsx"; // 导出百万级数据 exportLargeData(filePath); } private static void exportLargeData(String filePath) { // 每次写入的批次大小 final int batchSize = 10000; // 数据总条数 final int totalRows = 1_000_000; // 创建SXSSFWorkbook对象，内存中只保留100行，超过的部分会写入临时文件 SXSSFWorkbook workbook = new SXSSFWorkbook(100); workbook.setCompressTempFiles(true); // 启用临时文件压缩 // 创建工作表 Sheet sheet = workbook.createSheet("Large Data"); // 创建标题行 Row headerRow = sheet.createRow(0); String[] headers = {"ID", "Name", "Age"}; for (int i = 0; i < headers.length; i++) { Cell cell = headerRow.createCell(i); cell.setCellValue(headers[i]); } int rowNum = 1; // 数据开始的行号 try { // 按批次写入数据 for (int i = 0; i < totalRows / batchSize; i++) { // 模拟获取每批数据 List<Data> dataList = getDataBatch(rowNum, batchSize); // 将数据写入到Excel中 for (Data data : dataList) { Row row = sheet.createRow(rowNum++); row.createCell(0).setCellValue(data.getId()); row.createCell(1).setCellValue(data.getName()); row.createCell(2).setCellValue(data.getAge()); } // 处理完成一批数据后，可以选择清除缓存数据，防止内存溢出 ((SXSSFSheet) sheet).flushRows(batchSize); // 清除已写的行缓存 } // 将数据写入文件 try (FileOutputStream fos = new FileOutputStream(filePath)) { workbook.write(fos); } System.out.println("数据导出完成：" + filePath); } catch (IOException e) { e.printStackTrace(); } finally { // 关闭workbook并删除临时文件 workbook.dispose(); } } /** * 模拟分页获取数据 */ private static List<Data> getDataBatch(int startId, int batchSize) { List<Data> dataList = new ArrayList<>(batchSize); for (int i = 0; i < batchSize; i++) { dataList.add(new Data(startId + i, "Name" + (startId + i), 20 + (startId + i) % 50)); } return dataList; } // 数据类 static class Data { private final int id; private final String name; private final int age; public Data(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public String getName() { return name; } public int getAge() { return age; } } }来解释一下代码SXSSFWorkbook：SXSSFWorkbook(100)表示内存中最多保留100行数据，超过的部分会写入临时文件，节省内存。批次处理：通过batchSize控制每批次写入的数据量，以减少内存消耗。totalRows设置为1,000,000表示导出100万条数据。模拟数据生成：getDataBatch方法模拟分页获取数据，每次返回一批数据。清除缓存行：每次写入一批数据后，通过flushRows(batchSize)将缓存的行从内存中清除，以控制内存占用。压缩临时文件：workbook.setCompressTempFiles(true)启用临时文件压缩，进一步减少磁盘空间占用。需要注意的事项临时文件：SXSSFWorkbook会在系统临时文件夹中生成临时文件，需要确保磁盘空间足够。资源释放：完成数据写入后需要调用workbook.dispose()以清理临时文件。性能优化：可根据机器内存调整batchSize和SXSSFWorkbook缓存行数，避免频繁刷新和内存溢出。转载自https://www.cnblogs.com/wgjava/p/18510650

MVC架构 mvc是一种架构模型，本身并没有新功能，只是对项目的一种规范，方便后期进行维护；mvc架构将模型（M），视图（V)和控制（C）割离开，这么做可以提高代码书写的效率和后期维护；  MVC分层次介绍 模型（MODEL） 模型负责封装应用的状态，并实现应用的功能； 封装的是数据源和所有对这些数据的操作； 在组件中，模型表示组件的状态和操作状态的方法。  模型通常分为数据模型和业务逻辑模型：  数据模型 数据模型主要存放业务数据，如订单，用户信息等。 业务逻辑模型 业务逻辑模型往往是对数据的处理，如订单和用户信息的修改。 mvc的三个部件中模型拥有处理的处理能力，安装上文所说，M可以连接和处理数据库。（EJBs和ColdFusion Components构建对象处理数据库）被模型返回的数据是中立的（模型于数据格式无关），这么一来一个模型可以被多个视图调用。可以减少代码的重复性。  视图（VIEW） ** 视图是将模型的内容呈现出来，用户可以通过对视图的操作进而操作模型，封装的是对数据源Model的显示；** 一个模型可以被多个视图复用，一个视图理论上也可以和多个模型进行关联； 视图从模型中获取展示的数据，然后用自己的方法展示给用户。如用户点击H5页面的登录，视图会给模型提交用户的数据，视图接收模型的数据，然后按照自己的方式展示给用户。  在实际WEB项目中，视图通常是HTML，XHTML，XML/XSL，WML代码组成的界面。 在MVC模式中，视图只是起到展示的作用，真正处理数据其实并没有发生。 控制器（CONTROLLER） ** 控制器时用来出来视图和模型关系的组件。封装的是外界对模型的操作。** 这些操作一般为转发给模型，模型处理数据，并调用模型中相应的一个或多个方法； 一般控制器是在模型和视图之间作为沟通的组件存在的。 用户填写完账号密码由控制器接收处理并转发给模型。可以让视图和控制器之间的耦合关系更加密切；严格的分工可以提高工作的效率。  当控制器接收到用户的请求之后，会将用户的数据和模型的更新相映射，也就是调用模型来实现用户请求的功能；控制器会选择响应应用的视图，把模型更新后的数据发送给视图，视图按照自己的方式展示给用户；  当点击WEB的超链接和发送HTML表单时，控制器本身并不传输任何数据，也不做任何处理。只是接收请求并决定调用哪个模型进行构建去处理请求，然后决定用哪个视图来显示模型返回的数据。 MVC的组件关系 根据上文的描述，Model和View是严格分开的，甚至他们之间互相不知道彼此。只有Controller作为中介连接他们两个。  视图里不会有逻辑的东西。控制器里没有展示的东西。一个模型会有很多的展示方法，每一个展示方法页不止一种模型。  比如：windows下打开文件夹；  文件夹的大图标小图标就是不同的视图但内容数据是一样的（模型数据一样）； 点击进入其他的文件夹内，视图一样但是数据不同。  即–模型和视图之间并非一一对应的。  而Controller作为模型和视图之间的桥梁，可以保证模型和视图之间相互制约；点击视图的操作控制器立即给出相应；  MVC交互关系：  登入程序后，展示视图用户在视图上进行操作，填写业务数据 用户点击提交来提交发出的请求 视图发出的请求传到控制器，其中包含想要完成什么样的业务功能及相关数据 控制器处理用户请求并封装，选择合适的模型，请求模型来处理用户请求的数据，接收模型的更新，并选择接下来用哪一个视图进行展示这些数据 模型会处理用户请求的业务功能，同时进行模型状态的维护和更新 当模型进行更新后模型会通知相应的视图进行更新 当视图接收到模型的通知后，会向模型进行状态查询，获取需要展示的数据，然后按照视图的规则进行展示 等待用户的下一次操作，重复上面的操作 JAVA EE的MVC架构 MVC是一种横向分层的模型。采用MVC模式的用户不可以直接访问JSP视图，即使不需要调用业务逻辑功能，也应该让用户的所有操作都经过控制器，由控制器转到视图。  JAVA EE中视图层一般JSP实现一个交互性高的异步通信Web应用。 模型层：一般以JAvaBean为主体，实现Java的业务主体 控制器：用Servlet实现，  JavaEE中通常把Servlet+JSP+Javabean的模型称为Model2模型，基本划分如下：  Javabean作为模型，既可以作为数据模型来封装业务数据，也可以作为业务逻辑模型来实现业务的操作；其中数据模型用来存储和传递业务数据。业务逻辑模型接收控制器传来的模型请求更新后，执行特定的业务逻辑 处理，返回相应的执行结果； JSP作为视图，负责提供页面给用户展示数据。提供相应的表单（Form）来相应用户的请求，并在适当的时候（比如用户点击提交按钮）向控制器发送用户请求来要求模型进行更新； Servlet作为控制器，用来接收用户提交的请求，并获取请求中的数据，将其转化为业务模型中需要的数据模型，然后调用业务模型中相应的方法，请求业务模型进行更新，同时根据业务执行的结果来选择需要返回的视图。发送数据给相应的视图JSP； ————————————————                  原文链接：https://blog.csdn.net/Guo_Yuhua/article/details/119977966 

MVC架构模式，即模型-视图-控制器（Model-View-Controller）模式，是一种软件工程中的软件架构模式。它将应用程序分为三个主要部分：模型（Model）、视图（View）和控制器（Controller），以实现代码的分层组织和关注点的分离。  模型（Model） ： 模型代表应用程序的数据和业务逻辑。它负责处理数据的获取、存储和更新等操作，并且可以包含一些逻辑处理，当数据发生变化时，通知视图进行更新。模型是相对稳定的部分，重用率高，通常不直接与用户界面交互。  视图（View） ： 视图负责展示数据并呈现给用户。它从模型中提取数据并将其显示在用户界面上，但不处理任何业务逻辑或数据访问操作。视图的变化不会影响模型的内容，因为模型独立于视图进行数据管理。  控制器（Controller） ： 控制器作为模型和视图之间的桥梁，接收用户的输入并调用相应的模型和视图来响应这些输入。它处理所有的用户交互，如点击按钮、填写表单等，并根据需要更新模型和视图。控制器本身不输出任何结果或进行处理，仅作为中介角色。  通过这种分层设计，MVC架构模式提高了应用程序的可维护性、可扩展性和可测试性。各组件之间的职责明确，使得团队成员可以独立开发和维护不同的部分而不互相干扰。此外，由于模型和视图的分离，可以在不影响其他部分的情况下改进界面和用户交互。  总之，MVC架构模式是一种经典且灵活的设计范例，广泛应用于各种应用程序的开发中，包括Web应用、桌面应用和其他类型的应用程序。  MVC架构模式的历史发展和演变是什么？ MVC（Model-View-Controller）架构模式的历史发展和演变可以追溯到20世纪70年代末期。最初，这种架构模式是由Trygve Reenskaug在Xerox PARC的Smalltalk-80项目中提出的。Smalltalk-80是当时用于开发图形用户界面应用程序的一个重要平台，而MVC模式正是为了组织这些应用程序而设计的。  在Smalltalk-80环境中，MVC架构通过将应用程序分为三个主要部分来实现：模型（Model）、视图（View）和控制器（Controller）。模型负责数据处理和业务逻辑，视图负责展示数据并允许用户交互，控制器则作为模型和视图之间的中介，处理用户的输入和请求。  随着时间的推移，MVC架构逐渐被广泛应用于不同的技术平台和编程语言中。例如，Sun公司的Java平台也采用了类似的架构模式，并且后来发展出了许多变体架构，如MVVM（Model-View-ViewModel）等。这些变体架构进一步扩展了MVC的基本概念，以适应更复杂的应用场景和需求。  此外，MVC架构也在Web应用领域得到了广泛应用。经典的MVC框架如Ruby on Rails，极大地推动了MVC模式的普及和发展。其他著名的MVC框架还包括ASP.NET MVC等，它们证明了MVC架构在提高代码可维护性和可测试性方面的优势。  尽管MVC架构在软件开发中取得了巨大成功，但其应用过程中也存在一些问题。例如，由于不同变体之间的混淆，MVC常常被误用。因此，在实际应用中需要对MVC的不同变体有清晰的理解和区分。  总结来说，MVC架构自其诞生以来已经经历了显著的发展和演变。  如何在实际项目中实现MVC架构模式以提高软件开发的效率和质量？ 在实际项目中实现MVC架构模式以提高软件开发的效率和质量，需要遵循以下步骤和原则：  明确角色分工：  模型（Model） ：负责数据处理和业务逻辑。它与视图（View）完全独立，确保数据逻辑不被界面展示所干扰。 视图（View） ：负责数据显示和用户交互。它从模型获取数据并展示给用户，但不直接操作数据。 控制器（Controller） ：作为模型和视图之间的桥梁，接收用户的输入并调用相应的模型或视图进行响应。 分离代码结构：  将应用程序分为三个主要部分：模型、视图和控制器。这种分离有助于降低代码耦合度，提高可维护性和可扩展性。 模型层处理业务逻辑和数据访问，视图层负责界面展示，控制器层处理用户输入和逻辑控制。 并行开发：  由于MVC将不同部分分离，前端开发人员可以专注于视图的实现，而后端开发人员可以独立开发模型逻辑。这样可以实现并行开发，显著提高开发效率。 测试和部署：  各个部分独立开发后，可以分别进行单元测试和集成测试，确保每个部分的功能正确无误。这不仅提高了代码质量，还减少了整体系统的调试时间。 团队协作：  MVC架构促进了前后端开发人员的协作。前端开发者不需要了解后端逻辑，只需通过控制器与后端通信；后端开发者也不需要关注前端界面的具体实现。 选择合适的技术栈：  根据项目需求选择合适的技术栈。例如，在Web开发中，可以选择JSP、Servlet和POJO等技术来实现MVC设计模式。 持续优化和迭代：  在项目实施过程中，不断收集反馈并优化各部分的设计和实现。通过持续迭代，逐步完善系统功能和性能。 MVC架构模式与其他软件架构模式（如MVP、MVVM）的比较有哪些优缺点？ MVC（Model-View-Controller）架构模式是一种经典的软件架构模式，它将应用程序分为三个主要组件：模型（Model）、视图（View）和控制器（Controller）。这种模式在许多方面具有其独特的优缺点，与其他架构模式如MVP（Model-呈现阶段）和MVVM（Model-View-ViewModel）相比，各有不同的适用场景。  MVC的优点： 清晰的分层：MVC通过将业务逻辑、用户界面和控制逻辑分离到不同的组件中，有助于简化应用程序的测试和维护。 模块化程度高：当业务逻辑变更时，不需要修改View和Model，只需更换Controller即可，这使得系统的可扩展性和可维护性较高。 观察者模式支持多视图更新：MVC可以利用观察者模式实现多个视图的同时更新，从而提高系统的响应速度和用户体验。 MVC的缺点： 耦合性较高：在MVC中，View可以直接访问Model，导致View与Model之间存在高度耦合，这会降低系统的可读性、健壮性和可拓展性。 控制器职责过重：由于Controller需要处理所有与用户交互相关的逻辑，因此其职责较为复杂且容易变得过于庞大，影响开发效率和代码质量。 系统复杂度增加：实现MVC架构模式需要更多的代码和更复杂的设计，前期投入大，增加了项目的时间和成本。 MVP与MVC的比较： 耦合性：MVP通过引入Presenter来降低视图和模型之间的耦合，使得View不能直接访问Model，而是通过Presenter发出请求。这使得MVP在耦合性上优于MVC。 可维护性和测试性：由于呈现阶段的存在，MVP更容易进行单元测试和维护，因为呈现阶段隔离了视图和模型之间的交互。然而，呈现阶段可能会变得复杂，增加开发工作量。 MVVM与MVC的比较： 数据绑定：MVVM引入了数据绑定的概念，这使得View和ViewModel之间的关系更加紧密，减少了手动同步数据的需求。然而，数据绑定也可能导致性能问题，在执行复杂任务时可能会影响性能。 入口点：在MVVM中，View是应用程序的入口点，而在MVC中，Controller是入口点。这种设计上的差异决定了不同架构模式在实际应用中的适用性。 单元测试：MVVM由于其事件驱动的特性，更容易进行单元测试，而MVC的Controller与View的关系密切，可能会影响单元测试的独立性。 选择哪种架构模式取决于项目的具体需求、UI复杂度以及对测试和灵活性的要求。  在使用MVC架构模式时，如何处理数据更新和视图重定向的问题？ 在使用MVC架构模式时，处理数据更新和视图重定向的问题可以参考以下方法： 数据更新： 在MVC架构中，数据更新通常涉及以下几个步骤： 控制器（Controller） ：接收用户的输入并调用模型（Model）中的方法来更新数据。例如，如果用户点击了一个按钮来更新数据库中的记录，控制器会调用相应的模型方法来执行这个操作。 模型（Model） ：负责实际的数据更新逻辑。这可能包括与数据库交互的代码，如存储过程或直接的SQL查询。例如，可以编写一个实体方法来直接与数据库进行更新动作。 视图重定向： 视图重定向是将用户从当前处理请求定向到另一个视图或处理请求。Spring MVC提供了两种主要的重定向方式：转发和重定向。 重定向：使用RedirectView可以实现重定向。创建一个RedirectView实例后，它会调用HttpServletResponse.sendRedirect ()方法，从而将用户重定向到指定的URL。这种方式会使之前的请求（request）失效，并进入一个新的request作用域。  转发：使用ModelAndView可以实现转发。当需要将用户从当前视图转发到另一个视图时，可以使用ModelAndView对象，并将其视为重定向的一种形式。默认情况下，ModelAndView使用的是转发方式。 ————————————————                 原文链接：https://blog.csdn.net/m0_61505785/article/details/140901532 

MVC架构职责分析 MVC 设计模式一般指 MVC 框架，M（Model）指数据模型层，V（View）指视图层，C（Controller）指控制层。使用 MVC 的目的是将 M 和 V 的实现代码分离，使同一个程序可以有不同的表现形式。其中，View 的定义比较清晰，就是用户界面。 在 Web 项目的开发中，能够及时、正确地响应用户的请求是非常重要的。用户在网页上单击一个 URL 路径，这对 Web 服务器来说，相当于用户发送了一个请求。而获取请求后如何解析用户的输入，并执行相关处理逻辑，最终跳转至正确的页面显示反馈结果，这些工作往往是控制层（Controller）来完成的。 在请求的过程中，用户的信息被封装在 User 实体类中，该实体类在 Web 项目中属于数据模型层（Model）。 在请求显示阶段，跳转的结果网页就属于视图层（View）。 像这样，控制层负责前台与后台的交互，数据模型层封装用户的输入/输出数据，视图层选择恰当的视图来显示最终的执行结果，这样的层次分明的软件开发和处理流程被称为 MVC 模式。 总结如下： 视图层（View）：负责格式化数据并把它们呈现给用户，包括数据展示、用户交互、数据验证、界面设计等功能。 控制层（Controller）：负责接收并转发请求，对请求进行处理后，指定视图并将响应结果发送给客户端。 数据模型层（Model）：模型对象拥有最多的处理任务，是应用程序的主体部分，它负责数据逻辑（业务规则）的处理和实现数据操作（即在数据库中存取数据）。 业务流程见下图： Servlet+JSP+JavaBean Servlet+JSP+JavaBean 中 Servlet 用于处理用户请求，JSP 用于数据显示，JavaBean 用于数据封装，适合复杂的 Web 程序。 VO：视图层对象 例子：比如User类中有id，name，age，password等20个字段。而前端登录时所需数据只要name和password，这时可封装一个UserVo对象只包含name和password两个属性。 参考： https://baike.baidu.com/item/MVC%E6%A1%86%E6%9E%B6/9241230?fromtitle=mvc&fromid=85990&fr=aladdin http://c.biancheng.net/spring_mvc/mvc.html https://www.bilibili.com/video/BV1aE41167Tu?p=2 ————————————————             原文链接：https://blog.csdn.net/qq_38256519/article/details/121895614 

一、SpringMVC 简介 1. 什么是 MVC MVC 是一种软件架构的思想，将软件按照模型、视图、控制器来划分 M：Model，模型层，指工程中的 JavaBean，作用是处理数据。JavaBean 分为两类： 一类称为实体类 Bean：专门存储业务数据的，如 Student、User 等 一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。 V：View，视图层，指工程中的 html 或 jsp 等页面，作用是与用户进行交互，展示数据 C：Controller，控制层，指工程中的 servlet，作用是接收请求和响应浏览器 MVC 的工作流程：用户通过视图层发送请求到服务器，在服务器中请求被 Controller 接收，Controller 调用相应的 Model 层处理请求，处理完毕将结果返回到 Controller，Controller 再根据请求处理的结果找到相应的 View 视图，渲染数据后最终响应给浏览器 2. 什么是 SpringMVC SpringMVC 是 Spring 的一个后续产品，是 Spring 的一个子项目 SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目表述层开发的首选方案。 注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台 servlet  3. SpringMVC 的特点 Spring 家族原生产品，与 IOC 容器等基础设施无缝对接 基于原生的 Servlet，通过了功能强大的前端控制器 DispatcherServlet，对请求和响应进行统一处理 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案 代码清新简洁，大幅度提升开发效率 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可 性能卓著，尤其适合现代大型、超大型互联网项目要求 二、SpringMVC 入门案例 1. 创建 Maven 项目 创建 Maven web 项目 打包方式是 war 完善目录结构 目录结构如下：  2. 添加依赖 <?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.xszx</groupId>     <artifactId>springmvc_20240620</artifactId>     <version>1.0-SNAPSHOT</version>     <packaging>war</packaging>       <dependencies>         <!-- SpringMVC -->         <dependency>             <groupId>org.springframework</groupId>             <artifactId>spring-webmvc</artifactId>             <version>5.3.1</version>         </dependency>           <!-- 日志 -->         <dependency>             <groupId>ch.qos.logback</groupId>             <artifactId>logback-classic</artifactId>             <version>1.2.3</version>         </dependency>           <!-- ServletAPI -->         <dependency>             <groupId>javax.servlet</groupId>             <artifactId>javax.servlet-api</artifactId>             <version>3.1.0</version>             <scope>provided</scope>         </dependency>     </dependencies>       <build>         <plugins>             <plugin>                 <groupId>org.apache.tomcat.maven</groupId>                 <artifactId>tomcat7-maven-plugin</artifactId>                 <version>2.2</version>                 <configuration>                     <port>8080</port>                     <path>/</path>                     <uriEncoding>UTF-8</uriEncoding>                     <server>tomcat7</server>                 </configuration>             </plugin>         </plugins>     </build> </project>  注：由于 Maven 的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠传递性导入。   3. 配置 web.xml 注册 SpringMVC 的前端控制器 DispatcherServlet。  <?xml version="1.0" encoding="UTF-8"?> <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_4_0.xsd"          version="4.0">       <!-- 配置SpringMVC的前端控制器，对浏览器发起的请求进行统一处理 -->     <servlet>         <servlet-name>dispatcherServlet</servlet-name>         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>         <!-- 通过初始化参数指定SpringMVC配置文件的路径和名称 -->         <init-param>             <!-- 参数名contextConfigLocation是固定值 -->             <param-name>contextConfigLocation</param-name>             <param-value>classpath:springMVC.xml</param-value>         </init-param>         <!-- 表示服务器一启动就会加载该Servlet -->         <load-on-startup>1</load-on-startup>     </servlet>          <servlet-mapping>         <servlet-name>dispatcherServlet</servlet-name>         <!--             / 所匹配的请求可以是/login或.html或.js或.css方式的请求路径             但是/不能匹配.jsp请求路径的请求         -->         <url-pattern>/</url-pattern>     </servlet-mapping> </web-app>  注：  <url-pattern> 标签中使用 / 和 /* 的区别：  / 所匹配的请求可以是 /login 或 .html 或 .js 或 .css 方式的请求路径，但是 / 不能匹配 .jsp 请求路径的请求  因此就可以避免在访问 jsp 页面时，该请求被 DispatcherServlet 处理，从而找不到相应的页面  /* 则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用 \* 的写法  4. 编写 SpringMVC 的配置文件 <?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.xsd    http://www.springframework.org/schema/context    https://www.springframework.org/schema/context/spring-context.xsd    http://www.springframework.org/schema/mvc    https://www.springframework.org/schema/mvc/spring-mvc.xsd">       <!-- 配置扫描 -->     <context:component-scan base-package="com.xszx.controller"></context:component-scan>       <!-- 配置注解驱动 -->     <mvc:annotation-driven></mvc:annotation-driven> </beans>  5. 编写 controller 层代码 package com.xszx.controller;   import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping;   @Controller // 将该类交给SpringMVC容器管理 @RequestMapping("/hello") // 请求映射路径 public class HelloController {       @RequestMapping("/say") // 请求映射路径     public String say(){         System.out.println("say...");         return "/abc.jsp"; // 转发到根目录底下的abc.jsp页面     } } 6. 编写 abc.jsp 页面 <%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head>     <title>Title</title> </head> <body>   <h1>我是abc.jsp页面中的内容！</h1> </body> </html> 原文链接：https://blog.csdn.net/bear_309/article/details/141996730

Spring是IOC和AOP的容器框架，SpringMVC是基于Spring功能之上添加的Web框架，想用SpringMVC必须先依赖Spring。简单点的话可以将SpringMVC类比于Struts。Spring是IOC和AOP的容器框架，SpringMVC是基于Spring功能之上添加的Web框架，想用SpringMVC必须先依赖Spring。Spring可以说是一个管理bean的容器，也可以说是包括很多开源项目的总称，spring mvc是其中一个开源项目，所以简单走个流程的话，http请求一到，由容器（如：tomact）解析http搞成一个request，通过映射关系（路径，方法，参数啊）被spring mvc一个分发器去找到可以处理这个请求的bean，那tomcat里面就由spring管理bean的一个池子（bean容器）里面找到，处理完了就把响应返回回去。SpringMVC是一个MVC模式的WEB开发框架;Spring是一个通用解决方案, 最大的用处就是通过Ioc/AOP解耦, 降低软件复杂性, 所以Spring可以结合SpringMVC等很多其他解决方案一起使用, 不仅仅只适用于WEB开发SSH:SSH 为 struts+spring+hibernate 的一个集成框架，是目前较流行的一种JAVA Web应用程序开源框架。　Struts　　Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。　Spring　　Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器。然而，这仅仅是完整图景中的一部分：Spring在使用IOC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。 Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了Hibernate和其他O/R mapping解决方案。Spring还提供了唯一的事务管理抽象，它能够在各种底层事务管理技术，例如JTA或者JDBC事务提供一个一致的编程模型。Spring提供了一个用标准Java语言编写的AOP框架，它给POJOs提供了声明式的事务管理和其他企业事务–如果你需要–还能实现你自己的aspects。这个框架足够强大，使得应用程序能够抛开EJB的复杂性，同时享受着和传统EJB相关的关键服务。Spring还提供了可以和IoC容器集成的强大而灵活的MVC Web框架。　Hibernate　　Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序实用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。原文链接：https://devpress.csdn.net/cloudnative/66d30095a1ed2f4c8540020b.html

SpringMVC作为MVC框架,与Struts 2 有着异曲同工之处,首先对比一下SpringMVC与Struts2的不同之处：     1. 机制：spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。     2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring3 mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去，在spring3 mvc中，一个方法对应一个request上下文。而 struts2框架是类级别的拦截，每次来了请求就创建一个Action，然后调用setter getter方法把request中的数据注入；struts2实际上是通过setter getter方法与request打交道的；struts2中，一个Action对象对应一个request上下文。     3. 参数传递：struts是在接受参数的时候，可以用属性来接受参数，这就说明参数是让多个方法共享的。     4. 设计思想上：struts更加符合oop的编程思想， spring就比较谨慎，在servlet上扩展。     5. intercepter的实现机制：struts有以自己的interceptor机制，spring mvc用的是独立的AOP方式。这样导致struts的配置文件量还是比spring mvc大，虽然struts的配置能继承，所以我觉得论使用上来讲，spring mvc使用更加简洁，开发效率Spring MVC确实比struts2高。spring mvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应，所以说从架构本身上spring3 mvc就容易实现restful url。struts2是类级别的拦截，一个类对应一个request上下文；实现restful url要费劲，因为struts2 action的一个方法可以对应一个url；而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。spring3 mvc的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架方法之间不共享变量，而struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码，读程序时带来麻烦。     6. 另外，spring3 mvc的验证也是一个亮点，支持JSR303，处理ajax的请求更是方便，只需一个注解@ResponseBody ————————————————                     原文链接：https://blog.csdn.net/SpringFileld/article/details/38414929 

MVC MVC：MVC是一种设计模式 MVC的原理图：  分析： M-Model 模型（完成业务逻辑：有javaBean构成，service+dao+entity） V-View 视图（做界面的展示  jsp，html……） C-Controller 控制器（接收请求—>调用模型—>根据结果派发页面） 2、SpringMVC     SpringMVC是一个MVC的开源框架     SpringMVC=Struts2+Spring   ， SpringMVC就相当于是Struts2加上Sring的整合      SpringMVC是Spring的一个后续产品，其实就是Spring在原有基础上，又提供了web应用的MVC模块，可以简单的把SpringMVC理解为是Spring的一个模块  （类似AOP，IOC这样的模块），网络上经常会说SpringMVC和Spring无缝集成，其实SpringMVC就是Spring的一个子模块，所以根本不需要同Spring进行整合。 SpringMVC的原理图： 看到这个图大家可能会有很多的疑惑，现在我们来看一下这个图的步骤：（可以对比MVC的原理图进行理解）  第一步:  用户发起请求到前端控制器（DispatcherServlet） 第二步：前端控制器请求处理器映射器（HandlerMappering）去查找处理器（Handle）：通过xml配置或者注解进行查找 第三步：找到以后处理器映射器（HandlerMappering）像前端控制器返回执行链（HandlerExecutionChain） 第四步：前端控制器（DispatcherServlet）调用处理器适配器（HandlerAdapter）去执行处理器（Handler） 第五步：处理器适配器去执行Handler 第六步：Handler执行完给处理器适配器返回ModelAndView 第七步：处理器适配器向前端控制器返回ModelAndView 第八步：前端控制器请求视图解析器（ViewResolver）去进行视图解析 第九步：视图解析器像前端控制器返回View 第十步：前端控制器对视图进行渲染 第十一步：前端控制器向用户响应结果  看到这些步骤我相信大家很感觉非常的乱，这是正常的，但是这里主要是要大家理解springMVC中的几个组件：  前端控制器（DispatcherServlet）：接收请求，响应结果，相当于电脑的CPU。 处理器映射器（HandlerMapping）：根据URL去查找处理器 处理器（Handler）：（需要程序员去写代码处理逻辑的） 处理器适配器（HandlerAdapter）：会把处理器包装成适配器，这样就可以支持多种类型的处理器，类比笔记本的适配器（适配器模式的应用） 视图解析器（ViewResovler）：进行视图解析，多返回的字符串，进行处理，可以解析成对应的页面  原文链接：https://blog.csdn.net/rzrenyu/article/details/78513595 

SpringMVC 什么是MVC模型 MVC全称Model View Controller，是一种设计创建Web应用程序的模式。这三个单词分别代表Web应用程序的三个部分： Model（模型）：指数据模型。用于存储数据以及处理用户请求的业务逻辑。在Web应用中，JavaBean对象，业务模型等都属于Model。 View（视图）：用于展示模型中的数据的，一般为jsp或html文件。 Controller（控制器）：是应用程序中处理用户交互的部分。接受视图提出的请求，将数据交给模型处理，并将处理后的结果交给视图显示。 SpringMVC SpringMVC是一个基于MVC模式的轻量级Web框架，是Spring框架的一个模块，和Spring可以直接整合使用，我们使用的版本是Spring6，所以JDK需要17以上。SpringMVC代替了Servlet技术，它通过一套注解，让一个简单的Java类成为处理请求的控制器，而无须实现任何接口。  案例 使用maven创建web项目，补齐包结构。 引入相关依赖 <dependencies>   <!-- Spring核心依赖 -->   <dependency>     <groupId>org.springframework</groupId>     <artifactId>spring-context</artifactId>     <version>6.0.11</version>   </dependency>   <!-- SpringMVC -->   <dependency>     <groupId>org.springframework</groupId>     <artifactId>spring-web</artifactId>     <version>6.0.11</version>   </dependency>   <dependency>     <groupId>org.springframework</groupId>     <artifactId>spring-webmvc</artifactId>     <version>6.0.11</version>   </dependency>   <!-- Servlet -->   <dependency>     <groupId>jakarta.servlet</groupId>     <artifactId>jakarta.servlet-api</artifactId>     <version>6.0.0</version>     <scope>provided</scope>   </dependency>   <!-- JSP -->   <dependency>     <groupId>jakarta.servlet.jsp</groupId>     <artifactId>jakarta.servlet.jsp-api</artifactId>     <version>3.0.0</version>     <scope>provided</scope>   </dependency> </dependencies> 在web.xml中配置前端控制器DispatcherServlet。 <web-app>   <display-name>Archetype Created Web Application</display-name>   <!--SpringMVC前端控制器，本质是一个Servlet，接收所有请求，在容器启动时就会加载-->   <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.xml</param-value>     </init-param>     <load-on-startup>1</load-on-startup>   </servlet>   <servlet-mapping>     <servlet-name>dispatcherServlet</servlet-name>     <url-pattern>/</url-pattern>   </servlet-mapping> </web-app> 4.编写SpringMVC核心配置文件springmvc.xml，该文件和Spring配置文件写法一样。 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:mvc="http://www.springframework.org/schema/mvc"     xmlns:context="http://www.springframework.org/schema/context"     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/mvc     http://www.springframework.org/schema/mvc/spring-mvc.xsd     http://www.springframework.org/schema/context     http://www.springframework.org/schema/context/spring-context.xsd">   <!-- 扫描包 -->   <context:component-scan base-package="com.jjy"/>   <!-- 开启SpringMVC注解的支持 -->   <mvc:annotation-driven/> </beans> 5.编写控制器  @Controller public class MyController1 {   // 该方法的访问路径是/c1/hello1   @RequestMapping("/c1/hello1")   public void helloMVC(){     System.out.println("hello SpringMVC！");    } } 配置tomcat10启动项目，访问 http://localhost:8080/c1/hello1 SpringMVC执行流程  SpringMVC的组件  DispatcherServlet：前端控制器，接受所有请求，调用其他组件。 HandlerMapping：处理器映射器，根据配置找到方法的执行链。 HandlerAdapter：处理器适配器，根据方法类型找到对应的处理器。 ViewResolver：视图解析器，找到指定视图。 组件的工作流程  客户端将请求发送给前端控制器。 前端控制器将请求发送给处理器映射器，处理器映射器根据路径找到方法的执行链，返回给前端控制器。 前端控制器将方法的执行链发送给处理器适配器，处理器适配器根据方法类型找到对应的处理器。 处理器执行方法，将结果返回给前端控制器。 前端控制器将结果发送给视图解析器，视图解析器找到视图文件位置。 视图渲染数据并将结果显示到客户端。 SpringMVC封装参数 简单数据类型 在Servlet中我们通过request.getParameter(name)获取请求参数。该方式存在两个问题：  请求参数较多时会出现代码冗余。 与容器紧耦合。 而SpringMVC支持参数注入的方式用于获取请求数据，即将请求参数直接封装到方法的参数当中。用法如下：  编写控制器方法 // 封装为简单数据类型类型参数 @RequestMapping("/c1/param1") public void simpleParam(String username,int age){   System.out.println(username);   System.out.println(age); 访问该方法时，请求参数名和方法参数名相同，即可完成自动封装。 http://localhost:8080/c1/param1?username=bz&age=10  简单对象 SpringMVC支持将参数直接封装为对象，写法如下：  编写实体类 public class Student {   private int id;   private String name;   private String sex;   // 省略getter/setter/tostring } 编写控制器方法 // 封装为简单对象类型参数 @RequestMapping("/c1/param2") public void objParam(Student student){   System.out.println(student); } 访问该方法时，请求参数名和对象参数的属性名相同，即可完成自动封装。 http://localhost:8080/c1/param2?id=1&name=bz&sex=female  关联对象 SpringMVC还可以将请求参数封装为关联对象，即对象的属性也是一个对象。写法如下：  编写实体类 public class Student {   private int id;   private String name;   private String sex;   private Address address; // 地址对象   // 省略getter/setter/tostring }  public class Address {   private String info; //地址信息   private String postcode; //邮编   // 省略getter/setter/tostring } 编写控制器方法 // 获取关联对象类型参数 @RequestMapping("/c1/param3") public void objParam2(Student student){     System.out.println(student); } 访问该方法时，请求参数名和方法参数的属性名相同，即可完成自动封装。 http://localhost:8080/c1/param3?id=1&name=bz&sex=female&address.info=beijing&address.postcode=030000  我们也可以使用表单发送带有参数的请求：  <%@ page contentType="text/html;charset=UTF-8" language="java" %> <html>  <head>    <title>表单提交</title>  </head>  <body>    <form action="/c1/param3" method="post">      id:<input name="id">      姓名:<input name="name">      性别:<input name="sex">      住址:<input name="address.info">      邮编:<input name="address.postcode">      <input type="submit">    </form>  </body> </html> 原文链接：https://blog.csdn.net/m0_74436895/article/details/142927915

一、SpringMVC简介 1、什么是MVC MVC是一种软件架构模式（是一种软件架构设计思想，不止Java开发中用到，其它语言也需要用到），它将应用分为三块： M：Model（模型），负责业务处理及数据的收集 V：View（视图），负责数据的展示 C：Controller（控制器），负责调度。它是一个调度中心，它来决定什么时候调用Model来处理业务，什么时候调用View视图来展示数据   MVC架构模式的描述：前端浏览器发送请求给web服务器，web服务器中的Controller接收到用户的请求，Controller负责将前端提交的数据进行封装，然后Controller调用Model来处理业务，当Model处理完业务后会返回处理之后的数据给Controller，Controller再调用View来完成数据的展示，最终将结果响应给浏览器，浏览器进行渲染展示页面。  2、MVC架构模式与三层模型的区别 什么是三层模型  三层模型就是由Controller控制器和View视图组成的表现层，将Model数据模型拆封为业务层和与数据库交互的持久层 MVC架构模式与三层模型的区别？ MVC和三层模型都采用了分层结构来设计应用程序，都是降低耦合度，提高扩展力，提高组件复用性 区别在于他们的关注点不同 三层模型更加关注业务逻辑组件的划分 MVC架构模式关注的是整个应用程序的层次关系和分离思想 现代的开发方式大部分都是MVC架构模式结合三层模型一起用 3、什么是SpringMVC SpringMVC是一个实现了MVC架构模式的Web框架，底层基于Servlet实现 SpringMVC已经将MVC架构模式实现了，因此只要我们是基于SpringMVC框架写代码 Spring框架中有一个子项目叫做Spring Web，Spring Web子项目当中包含很多模块 Spring MVC Spring WebFlux Spring Web Services Spring Web Flow Spring WebSocket Spring Web Services Client Spring架构图如下，其中Web中的servlet指的就是Spring MVC 二、HelloWorld程序 1、pom文件 <?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.xc</groupId>     <artifactId>springmvc-xml</artifactId>     <version>1.0-SNAPSHOT</version>      <packaging>war</packaging>      <dependencies>         <!--springmvc-->         <dependency>             <groupId>org.springframework</groupId>             <artifactId>spring-webmvc</artifactId>             <version>5.3.1</version>         </dependency>         <!--servletAPI-->         <dependency>             <groupId>javax.servlet</groupId>             <artifactId>javax.servlet-api</artifactId>             <version>3.1.0</version>             <scope>provided</scope>         </dependency>         <!--spring5和thymeleaf整合-->         <dependency>             <groupId>org.thymeleaf</groupId>             <artifactId>thymeleaf-spring5</artifactId>             <version>3.0.11.RELEASE</version>         </dependency>     </dependencies>      <properties>         <maven.compiler.source>8</maven.compiler.source>         <maven.compiler.target>8</maven.compiler.target>         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>     </properties>  </project> 2、springmvc.xml 组件扫描。spring扫描这个包中的类，将这个包中的类实例化并纳入IoC容器的管理 视图解析器。视图解析器（View Resolver）的作用主要是将Controller方法返回的逻辑视图名称解析成实际的视图对象。视图解析器将解析出的视图对象返回给DispatcherServlet，并最终由DispatcherServlet将该视图对象转化为响应结果，呈现给用户 <?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"        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">     <!--组件扫描-->     <context:component-scan base-package="com.xc.controller"/>     <!--视图解析器-->     <bean id="thymeleafViewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">         <!--作用于视图渲染的过程中，可以设置视图渲染后输出时采用的编码字符集-->         <property name="characterEncoding" value="UTF-8"/>         <!--如果配置多个视图解析器，它来决定优先使用哪个视图解析器，它的值越小优先级越高-->         <property name="order" value="1"/>         <!--当 ThymeleafViewResolver 渲染模板时，会使用该模板引擎来解析、编译和渲染模板-->         <property name="templateEngine">             <bean class="org.thymeleaf.spring5.SpringTemplateEngine">                 <!--用于指定 Thymeleaf 模板引擎使用的模板解析器。模板解析器负责根据模板位置、模板资源名称、文件编码等信息，加载模板并对其进行解析-->                 <property name="templateResolver">                     <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">                         <!--设置模板文件的位置（前缀）-->                         <property name="prefix" value="/WEB-INF/templates/"/>                         <!--设置模板文件后缀（后缀），Thymeleaf文件扩展名不一定是html，也可以是其他，例如txt，大部分都是html-->                         <property name="suffix" value=".html"/>                         <!--设置模板类型，例如：HTML,TEXT,JAVASCRIPT,CSS等-->                         <property name="templateMode" value="HTML"/>                         <!--用于模板文件在读取和解析过程中采用的编码字符集-->                         <property name="characterEncoding" value="UTF-8"/>                     </bean>                 </property>             </bean>         </property>     </bean> </beans> 3、配置web.xml文件 Spring MVC是一个web框架，在javaweb中谁来负责接收请求，处理请求，以及响应呢？当然是Servlet 在SpringMVC框架中已经为我们写好了一个Servlet，它的名字叫做：DispatcherServlet，我们称其为前端控制器 既然是Servlet，那么它就需要在web.xml文件中进行配置： <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"          version="5.0">      <!--配置前端控制器-->     <servlet>         <servlet-name>springmvc</servlet-name>         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>         <!--手动设置springmvc配置文件的路径及名字-->         <init-param>             <param-name>contextConfigLocation</param-name>             <param-value>classpath:springmvc.xml</param-value>         </init-param>         <!--为了提高用户的第一次访问效率，建议在web服务器启动时初始化前端控制器-->         <load-on-startup>1</load-on-startup>     </servlet>     <servlet-mapping>         <servlet-name>springmvc</servlet-name>         <!-- /* 表示任何一个请求都交给DispatcherServlet来处理 -->         <!-- / 表示当请求不是xx.jsp的时候，DispatcherServlet来负责处理本次请求-->         <!-- jsp本质就是Servlet，因此如果请求是jsp的话，应该走它自己的Servlet，而不应该走DispatcherServlet -->         <!-- 因此我们的 url-pattern 使用 / -->         <url-pattern>/</url-pattern>     </servlet-mapping>  </web-app>   DispatcherServlet是SpringMVC框架为我们提供的最核心的类，它是整个SpringMVC框架的前端控制器，负责接收HTTP请求、将请求路由到处理程序、处理响应信息，最终将响应返回给客户端。  接收客户端的HTTP请求：DispatcherServlet监听来自Web浏览器的HTTP请求，Tomcat已经将请求数据解析为Request对象 处理请求的URL：DispatcherServlet将请求的URL与处理程序进行匹配，确定要调用哪个控制器(Controller)来处理此请求 调用相应的控制器：DispatcherServlet将请求发送给找到的控制器处理，控制器将执行业务逻辑，然后返回一个模型对象(Model) 渲染视图：DispatcherServlet将调用视图引擎，将模型对象呈现为用户可以查看的HTML页面 返回响应给客户端：DispatcherServlet将为用户生成的响应发送回浏览器，响应可以包括表单、JSON、XML、HTML以及其它类型的数据 4、html文件 <!DOCTYPE html> <html lang="en"> <head>     <meta charset="UTF-8">     <title>Title</title> </head> <body> hello world </body> </html> 原文链接：https://xuchang.blog.csdn.net/article/details/139730755

一.spring是什么? Spring是一个轻量级的IoC/DI和AOP容器的开源框架 二.spring的优点 1.Spring 能帮我们低侵入/低耦合地根据配置文件创建及组装对象之间的依赖关系   //解耦 2.Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制等   //提高代码重用性 3.Spring 能非常简单的且强大的声明式事务管理     //使用xml或注解的方法,底层用到动态代理 4.Spring 提供了与第三方数据访问框架（如JPA）无缝集成，且自己也提供了一套JDBC模板来方便数据库访问 5.Spring 提供与第三方Web框架无缝集成，且自己也提供了一套 SpringMVC 框架，来方便 Web 层搭建 三.Spring Ioc/DI Ioc: 1.控制反转,是一种设计思想,就是原本在程序中需要手动创建对象的权利,交给spring框架管理 2.Ioc容器是实现Ioc的载体,Ioc容器实际上就是个Map(key,value),map中存放各种对象 3.Ioc容器就像一个工厂一样,当我们需要创建一个对象时,只需要配置好配置文件或贴注解即可,   完全不用考虑对象时如何被创建出来的 4.将对象相互依赖的关系交给ioc容器管理,这样可以很大程度简化应用开发 5.使用Ioc的话,我们只需要配置好,在需要的地方引用就好,这大大的增加了项目的可维护性且降低了开发难度 DI: 1.指 Spring 创建对象的过程中，将对象依赖属性通过配置设值给该对象 2.就是给对象的属性设置属性值 //Ioc创建对象,Di给属性设置值 四.Spring AOP Aop:面向切面编程 1.能够将那些与业务无关,却为业务模块所共同调用的逻辑和责任封装起来,   便于减少重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性 2.Spring Aop就是基于动态代理的,当要代理的对象实现了某个接口,就会使用Jdk动态代理 3.如果没有某个接口,就是使用cglib生成一个被代理对象的子类作为代理 //使用aop之后我们可以把一些通用的功能抽象出来,在需要的时候自己使用即可,这样大大的简化了代码量 //常用的aop的有 事务处理  日志管理  权限控制 五.Spring 中的 bean 的作用域 //作用域:在 Spring 容器中是指其创建的 bean 对象相对于其他 bean 对象的请求可见范围 singleton : 唯一bean 实例，Spring 中的 bean 默认都是单例的。 prototype : 多例,每次请求都会创建一个新的 bean 实例,多例只会初始化和销毁,不会存到容器中进行管理 request : 每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效。 session : 每一次HTTP请求都会产生一个新的 bean，该bean仅在当前 HTTP session 内有效。  /*使用总结:在开发中主要使用 scope="singleton"。对于 Struts1 的 Action 使用 request，           Struts2 中的 Action 使 用 prototype 类型，其他使用 singleton，即不配置 六. SpringMVC工作原理 1、客户端发出http请求给web服务器，web服务器对http请求进行解析，如果匹配DispatcherServlet的请求映射路径（在web.xml中指定），web容器将请求转交给DispatcherServlet.  2、DipatcherServlet接收到这个请求之后将根据请求的信息（包括URL、Http方法、请求报文头和请求参数Cookie等）以及HandlerMapping的配置找到处理请求的处理器Controller(Handler)。  3、DispatclierServlet 根据 HandlerMapping 找到对应的Handler,处理权交给Handler ( Handler将具体的处理进行封装），再由具体的处理适配器 HandlerAdapter对Handler进行具体的调用。  5、Handler对数据处理完成以后将返回一个ModeAndView对象给DispatcherServlet.  6、Handler返回的ModelAndView只是一个逻辑视图并不是一个正式的视图,dspatcherSevlet通过ViewResolver将邀辑视图转化为真正的视图view(这句话简单的就是返回一个要返回的页面的相对路径，通过试图解析器转换成具体那个页面)。  7、DispatcherServlet通过model解析出ModeAndView中的参数进行解析最终展现出完整的view并返回给客户端  //简化 1. 客户端(浏览器)发送请求到dispatcherServlet前端控制器  2. DispatcherServlet 根据请求信息调用 HandlerMapping ，解析请求对应的 Handler  3. 解析到对应的 Handler（也就是我们平常说的 Controller 控制器）后，开始由HandlerAdapter 适配器处理 4. HandlerAdapter 会根据 Handler 来调用真正的处理器开处理请求，并处理相应的业务逻辑 5. 处理器处理完业务后，会返回一个 ModelAndView 对象，Model 是返回的数据对象，View 是个逻辑上的 View  6. ViewResolver 会根据逻辑 View 查找实际的 View  7. DispaterServlet 把返回的 Model 传给 View （视图渲染） 8. 把 View 返回给请求者（浏览器） 七.Spring 管理事务的方式 1. 编程式事务，在代码中硬编码。(不推荐使用) 2. 声明式事务，在配置文件中配置（推荐使用） //声明式事务又分为两种： 1. 基于XML的声明式事务 2. 基于注解的声明式事务 八.Spring 框架中用到的设计模式 1.工厂设计模式 : Spring使用工厂模式通过 BeanFactory 、ApplicationContext 创建 bean 对象 2.代理设计模式 : Spring AOP 功能的实现 3.单例设计模式 : Spring 中的 Bean 默认都是单例的 4.模板方法模式 : Spring 中 jdbcTemplate 、hibernateTemplate 等以Template 结尾的对数据库操作类，                它们就使用到了模板模式 5.包装器设计模式 : 我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库,                 这种模式让我们可以根据客户的需求能够动态切换不同的数据源。 6.观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。 7.适配器模式:Spring AOP的增强或通知(Advice)使用到了适配器模式,spring MVC中也是用到了适配器模式适配 Controller 九.小结 1.spring的核心思想Ioc/DI和aop 2.使用spring不用处理对象之间的依赖关系,能够大大的降低我们代码的耦合度,增加项目的可维护性 3.使用spring我们不用关心对象是怎么创建的,只需要配置好配置文件或贴注解即可,很大程度简化应用开发 4.使用spring能够将与业务无关的代码,,却为业务模块所共同调用的逻辑使用aop将其抽象出来,提高代码可重用性 5.spring提供与第三方web框架无缝集成,并且自己也提供一套SpringMVC框架 使用spring需要配置大量的xml文件,其实也是有点头疼的,但是springboot可以帮我们完美的解决这些问题 原文连接：https://devpress.csdn.net/cloudnative/66d41b140bfad230b8b2e176.html

spring是什么? pring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。  Spring项目出发点： 目的：提供一种贯穿始终的解决方面，将各种专用框架整合成一个连贯的整体框架，简化企业级应用的开发（有点像粘合剂）  鼓励最佳实践： 例如spring将“针对接口编程”的成本降到了最小  非侵入性： 应用对象尽量避免依赖框架，IoC和AOP是避免依赖的关键技术  统一配置： 好的框架应该让应用配置灵活且统一  易于测试： 使单元测试尽可能简单  可扩展：  简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。    1.核心容器（Spring Core） 是Spring的核心容器，提供了Spring框架的基本功能；  此模块包含 的BeanFactory类是Spring的核心类，负责产生和管理Bean，是工程模式的实现；  采用Factory(工厂模式)实现了IOC（控制反转）将应用的配置和依赖性规范与实际的应用程序代码分开;  Spring以bean的方式组织和管理Java应用中发各个组件及其关系。  2.应用上下文（Spring Context） 是一个配置文件，向Spring框架提供上下文信息；  SpringContext模块继承BeanFactory类，添加了事件处理、国际化、资源装载、透明装载、以及数据校验等功能；  还提供了框架式的Bean的访问方式和企业级的功能，如JNDI访问，支持EJB、远程调用、继承模板框架、Email和定时任务调度等；  3.面向切面编程（Spring AOP） Spring AOP直接将面向方面的编程功能集成到了Spring框架中，所以很容易的使Spring框架管理的任何对象支持AOP（Spring集成了所有AOP功能。通过事务管理可以使任意Spring管理的对象AOP化）；  Spring AOP为基于Spring的应用程序中的对象提供了事务管理服务；  通过使用Spring AOP，不用依赖EJB组件，就可以将声明性事务管集成到应用程序中。  4.JDBC和DAO模块（Spring DAO） DAO（DataAccessObject）模式思想是将业务逻辑代码与数据库交互代码分离，降低两者耦合；  通过DAO模式可以使结构变得更为清晰，代码更为简；  DAO模块中的JDBC的抽象层，提供了有意义的异常层次结构，用该结构来管理异常处理，和不同数据库供应商所抛出的错误信息；  异常层次结构简化了数据库厂商的异常错误（不再从SQLException继承大批代码），极大的降低了需要编写的代码数量，并且提供了对声明式事务和编程式事务的支持；  5.对象实体映射（Spring ORM） SpringORM模块提供了对现有ORM框架的支持；  提供了ORM对象的关系工具，其中包括了Hibernate、JDO和 IBatis SQL Map等，所有的这些都遵从Spring的通用事务和DAO异常层次结构；  注意这里Spring是提供各类的接口（support），目前比较流行的下层数据库封闭映射框架，如mybatis,Hibernate等；  6.Web模块（Spring Web） 此模块建立在SpringContext基础之上，提供了Servlet监听器的Context和Web应用的上下文；  对现有的Web框架，如JSF、Tapestry、Structs等提供了集成；  SpringWeb模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。  7.MVC模块（Spring Web MVC） SpringWebMVC模块建立在Spring核心功能之上，拥有Spring框架的所有特性，能够适应多种多视图、模板技术、国际化和验证服务，实现控制逻辑和业务逻辑的清晰分离；  通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI;  IOC 控制反转(IoC=Inversion of Control)IoC，用白话来讲，就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：(依赖)控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。 IoC还有一个另外的名字：“依赖注入 (DI=Dependency Injection)” ，即由容器动态的将某种依赖关系注入到组件之中。  示例 创建工程---创建maven的web项目 pom文件     <properties>         <spring.version>5.3.6</spring.version>     </properties>          <dependencies>        <dependency>             <groupId>org.springframework</groupId>             <artifactId>spring-core</artifactId>             <version>${spring.version}</version>         </dependency>         <dependency>             <groupId>org.springframework</groupId>             <artifactId>spring-beans</artifactId>             <version>${spring.version}</version>         </dependency>         <dependency>             <groupId>org.springframework</groupId>             <artifactId>spring-context</artifactId>             <version>${spring.version}</version>         </dependency>     </dependencies>  spring配置文件 创建beans.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"        xsi:schemaLocation="http://www.springframework.org/schema/beans         https://www.springframework.org/schema/beans/spring-beans.xsd">  </beans>  示例代码 1.代码  /**  * 第一个Spring,输出"Hello,Spring!"。  */ public class HelloSpring {     // 定义who属性，该属性的值将通过Spring框架进行设置     private String who = null;     public HelloSpring(){      }     public HelloSpring(String who){         this.who = who;     }      /**      * 定义打印方法，输出一句完整的问候。      */     public void print() {         System.out.println("Hello," + who + "!");     }     public String getWho() {         return who;     }     public void setWho(String who) {         this.who = who;     }  }  2.beans.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"        xsi:schemaLocation="http://www.springframework.org/schema/beans         https://www.springframework.org/schema/beans/spring-beans.xsd">          <!-- id要唯一,class:指定类,不能是接口或者抽象类;默认情况,spring调用class指定类中不带参的构造方法 -->         <bean id="helloSpring" class="com.zking.springdemo.HelloSpring">                 <!-- 调用class类中的set+name方法,传value指定的值 -->                 <property name="who" value="spring"/>         </bean> </beans>  配置文件说明：  id：在容器中查找Bean的id(唯一、且不能以/开头)  class：bean的完整类名  scope:(singleton|prototype)默认是singleton singleton: 单例模式, 在每个Spring IoC容器中一个bean定义对应一个对象实例;spring在容器启动时，创建实例 ； prototype： 原型模式/多例模式, 一个bean定义对应多个对象实例；在用户使用bean对象时才创建  3.通过Spring的ApplicationContex 获取Bean  public class HelloSpringTest {     public static void main(String[] args) {         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");         HelloSpring h1 = (HelloSpring)ctx.getBean("helloSpring");         h1.print();     } }  注入方式 设值注入--通过调用对应的set方法注入     <bean id="helloSpring" class="com.zking.springdemo.HelloSpring">         <property name="who" value="spring"/>     </bean>  构造注入 <bean id="helloSpring2" class="com.zking.springdemo.HelloSpring">     <constructor-arg value="spring"></constructor-arg> </bean>  p注入--在beans.xml文件中额外引入p命名空间 xmlns:p="http://www.springframework.org/schema/p"  p注入--beans.xml中bean的配置 <bean id="helloSpring3" class="com.zking.springdemo.HelloSpring" p:who="spring"> </bean>  复杂属性的配置 依赖bean对象(重点)     <bean id="userDao" class="com.zking.springdemo.dao.impl.UserDaoImpl"></bean>     <bean id="userService" class="com.zking.springdemo.service.impl.UserServiceImpl">         <!--ref="userDao"依赖spring容器中的id为userDao的bean对象-->         <property name="userDao" ref="userDao"></property>     </bean>     <bean id="userService2" class="com.zking.springdemo.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>  List或数组 声明属性  private String[] array;  private List list;  配置文件  <property name="array">             <array>                 <value>足球</value>                 <value>蓝球</value>             </array>         </property>                  <property name="list">             <list>                  <value>jack</value>                 <value>rose</value>             </list>         </property>           Map private Map map;  配置文件          <property name="map">             <map>                 <entry key="en" value="english"></entry>                 <entry key="ch" value="chinese"></entry>             </map>         </property>  Properties private Properties prop;  配置文件          <property name="props">             <props>                 <prop  key="en">english</prop>                 <prop key="ch">chinese</prop>             </props>         </property>  多配置文件 系统一般会被分成多个模块，可以为每个模块配置一个配置文件，便于管理，在版本控制软件中也可以减少冲突  beans.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"        xsi:schemaLocation="http://www.springframework.org/schema/beans         https://www.springframework.org/schema/beans/spring-beans.xsd">      <import resource="spring_ioc.xml"/>      </beans>  spring_ioc.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:p="http://www.springframework.org/schema/p"        xsi:schemaLocation="http://www.springframework.org/schema/beans         https://www.springframework.org/schema/beans/spring-beans.xsd">      <!-- id要唯一,class:指定类,不能是接口或者抽象类;默认情况,spring调用class指定类中不带参的构造方法 -->     <bean id="helloSpring" class="com.zking.springdemo.HelloSpring">         <!-- 调用class类中的set+name方法,传value指定的值 -->         <property name="who" value="spring"/>     </bean>      <bean id="helloSpring2" class="com.zking.springdemo.HelloSpring">         <constructor-arg value="spring"></constructor-arg>     </bean>      <bean id="helloSpring3" class="com.zking.springdemo.HelloSpring" p:who="spring"></bean>      <bean id="userDao" class="com.zking.springdemo.dao.impl.UserDaoImpl"></bean>     <bean id="userService" class="com.zking.springdemo.service.impl.UserServiceImpl">     <!--ref="userDao"依赖spring容器中的id为userDao的bean对象-->     <property name="dao" ref="userDao"></property> </bean>     <bean id="userService2" class="com.zking.springdemo.service.impl.UserServiceImpl" p:dao-ref="userDao"/>      <!--复杂属性的配置-->     <bean id="testBean" class="com.zking.springdemo.TestBean">         <property name="list">             <list>                 <value>jack</value>                 <value>rose</value>             </list>         </property>         <property name="array">             <array>                 <value>足球</value>                 <value>蓝球</value>             </array>         </property>         <property name="map">             <map>                 <entry key="en" value="english"></entry>                 <entry key="ch" value="chinese"></entry>             </map>         </property>         <property name="props">             <props>                 <prop key="en">english</prop>                 <prop key="ch">chinese</prop>             </props>         </property>     </bean> </beans> ———————————————— 原文链接：https://blog.csdn.net/weixin_59196705/article/details/123842794