JavaEE SpringMVC复习纲要

绪论

●企业级应用

●Web开发的基本模型

1. 请求（Request）：客户端发送一个HTTP请求到服务器。

2. 处理（Handle）：服务器接收到请求后，根据请求的类型（如GET或POST）进行相应的处理。

3. 响应（Response）：服务器处理完请求后，生成一个HTTP响应，并将其发送回客户端。

4. 呈现（Render）：客户端接收到响应后，根据响应内容（通常是HTML、CSS和JavaScript）来呈现页面。

●Javaweb开发的发展历程

1. Servlet时代：在最初，Java Web开发主要依赖于Servlet。Servlet是运行在服务器上的一个小程序，用于处理客户端请求并生成响应。

2. JSP时代：随着JavaServer Pages（JSP）的引入，开发者可以在HTML中嵌入Java代码，使得页面开发变得更加简单。

3. 框架时代：为了解决Servlet和JSP在大型应用中的局限性，各种Java Web框架开始出现，如Struts、Spring MVC、JSF等。

4. 全栈框架和微服务：随着Spring Boot和Spring Cloud等现代框架的出现，Java Web开发变得更加高效和模块化。微服务架构也开始流行，允许开发者将应用拆分成多个小型、独立的服务。

●maven web项目的结构特点

• src

  ：源代码和资源文件夹。

  • main

    ：主代码和资源。

    • java：存放Java源代码。

    • resources：存放资源文件，如配置文件。

    • webapp

      ：Web应用的内容，如HTML、CSS、JavaScript和JSP文件。

      • WEB-INF：存放Web应用的配置文件，如web.xml。

• pom.xml：项目对象模型（Project Object Model），定义了项目的依赖、构建插件和其他配置。

Maven使用“约定优于配置”的原则，这意味着它有一套默认的项目结构和生命周期，开发者只需要遵循这些约定，就可以轻松地构建和管理项目。

Spring与AOP

●Spring容器基础概念：IOC与DI

IOC（Inversion of Control，控制反转）：这是Spring框架的核心概念之一。在传统的Java应用中，对象的创建和生命周期通常由程序直接控制。而IOC将这种控制权交给了外部容器（如Spring容器），由容器负责对象的创建和依赖关系的注入。这样可以使得应用程序更加模块化，易于测试和维护。

DI（Dependency Injection，依赖注入）：是IOC的一种实现方式。DI意味着组件的依赖关系由容器在运行时自动注入，而不是由组件自己控制。这样可以提高组件的解耦性，使得代码更加灵活。

●DI的方式及比较

1. 构造器注入：通过构造器参数来注入依赖。

2. 设值注入（Setter注入）：通过属性的setter方法来注入依赖。

3. 接口注入：通过接口方法来注入依赖（较少使用）。

比较：

• 构造器注入可以确保依赖不可变，且对象创建后即可使用。但它可能导致构造器参数过多，不易维护。

• Setter注入更加灵活，易于理解和实现。但它可能导致依赖不是及时注入，需要额外的代码来确保依赖的初始化。

●bean的配置

 <bean id="myBean" class="com.example.MyClass">
     <!-- 属性注入 -->
 </bean>

 @Component("myBean")
 public class MyClass {
     // ...
 }

 @Configuration
 public class AppConfig {
     @Bean
     public MyClass myBean() {
         return new MyClass();
     }
 }

●普通属性注入

 <bean id="myBean" class="com.example.MyClass">
     <property name="propertyName" value="value"/>
 </bean>

 public class MyClass {
     @Value("value")
     private String propertyName;
 }

●依赖bean的注入

 <bean id="myBean" class="com.example.MyClass">
     <property name="dependencyBean" ref="dependencyBeanId"/>
 </bean>
 <bean id="dependencyBeanId" class="com.example.DependencyClass"/>
 ​

 public class MyClass {
     @Autowired
     private DependencyClass dependencyBean;
 }

●容器中Bean的作用域

Spring定义了多种Bean的作用域，包括：

• Singleton：整个容器中只有一个实例。

• Prototype：每次请求都会创建一个新的实例。

• Request：每个HTTP请求有一个独立的实例。

• Session：每个HTTP会话有一个独立的实例。

• GlobalSession：用于portlet环境的每个全局会话。

●容器中Bean的生命周期

Spring容器中的Bean生命周期包括创建、初始化、使用和销毁等阶段。可以通过实现InitializingBean和DisposableBean接口，或者在bean配置中指定init-method和destroy-method来自定义初始化和销毁逻辑

●Spring项目开发步骤

1. 创建项目：使用Maven、Gradle等工具创建项目结构。

2. 添加依赖：在项目的构建配置文件中添加Spring和相关库的依赖。

3. 配置Spring容器：通过XML、注解或Java配置来配置bean。

4. 编写业务逻辑：实现应用程序的核心功能和业务逻辑。

5. 测试：编写和执行单元测试和集成测试。

6. 部署：将应用程序部署到服务器或容器中。

●AOP的基本特点

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它允许开发者定义跨多个对象的横切关注点（cross-cutting concerns），如日志、事务和安全性等。AOP的主要特点包括：

• 分离横切关注点：将横切关注点与业务逻辑分离，提高代码的模块化。

• 声明式编程：通过声明的方式定义横切逻辑，而不是编写侵入性的代码。

• 动态代理：AOP通常通过代理模式实现，在运行时动态地将横切逻辑织入到主业务逻辑中。

●AOP的基本概念

1. Aspect： Aspect是对横切关注点的模块化。它通常包含多个Pointcut和Advice。横切关注点是指那些影响整个应用程序的行为，如日志、事务、安全等，它们通常散布在系统的多个模块中。

2. Joinpoint： Joinpoint是程序执行过程中的特定点，如方法的调用、异常的抛出等。在Spring AOP中，只支持方法的Joinpoint，而在其他AOP框架如AspectJ中，还支持字段赋值、方法执行等Joinpoint。

3. Pointcut： Pointcut是一组Joinpoint的集合，它定义了Advice应该应用到哪些Joinpoint上。通过Pointcut表达式，我们可以选择性地应用Advice到匹配的Joinpoint上。

4. Advice： Advice是在Pointcut指定的Joinpoint上执行的动作。根据Advice在Joinpoint的执行时机，可以分为以下几种：

   • Before Advice：在Joinpoint之前执行。

   • After Advice：在Joinpoint之后执行，无论是否抛出异常。

   • After Returning Advice：在Joinpoint正常执行后执行。

   • After Throwing Advice：在Joinpoint抛出异常后执行。

   • Around Advice：环绕Joinpoint执行，可以控制Joinpoint的执行时机、是否执行以及执行前后做什么。

●SpringAOP增强处理的类型及特点

1. Before Advice：

   • 特点：在目标方法执行之前执行。

   • 用途：用于参数验证、权限检查等。

   • 示例：@Before注解。

2. After Returning Advice：

   • 特点：在目标方法正常返回后执行。

   • 用途：用于记录日志、清理资源等。

   • 示例：@AfterReturning注解。

3. After Throwing Advice：

   • 特点：在目标方法抛出异常后执行。

   • 用途：用于异常处理、错误日志记录等。

   • 示例：@AfterThrowing注解。

4. After (Finally) Advice：

   • 特点：在目标方法执行之后执行，无论是否抛出异常。

   • 用途：用于释放资源、清理操作等。

   • 示例：@After注解。

5. Around Advice：

   • 特点：包围目标方法的执行，可以在方法执行前后执行自定义逻辑，也可以选择是否执行目标方法。

   • 用途：用于事务管理、性能监控、缓存等。

   • 示例：@Around注解。

6. Introduction：

   • 特点：为原有的对象添加新的接口和实现。

   • 用途：用于在不修改原有代码的情况下，为对象添加新的行为。

   • 示例：@DeclareParents注解。

Mybatis/JPA

●ORM基本原理

ORM（Object-Relational Mapping，对象关系映射）是一种编程技术，用于实现对象和关系数据库之间的映射。ORM允许开发者以面向对象的方式操作数据库，而不需要直接编写SQL语句。基本原理包括：

1. 映射关系：ORM框架定义了一套规则，将对象的属性和数据库的表字段进行映射。

2. 对象持久化：ORM框架负责将对象的状态保存到数据库中，以及从数据库中恢复对象的状态。

3. 透明化SQL操作：开发者通过操作对象来间接执行数据库操作，ORM框架会自动生成相应的SQL语句

●MyBatis的基本原理

MyBatis是一个半自动的ORM框架，它允许开发者自定义SQL语句，同时提供了将SQL结果映射到对象的能力。MyBatis的基本原理包括：

1. SQL映射：开发者编写SQL语句，并通过XML或注解的方式定义SQL与对象的映射关系。

2. 动态SQL：MyBatis提供了动态SQL的功能，可以根据不同的条件动态生成SQL语句。

3. 数据访问对象（DAO）：MyBatis支持接口式编程，开发者定义DAO接口，MyBatis会自动生成接口的实现。

4. 会话工厂（SqlSessionFactory）：MyBatis通过SqlSessionFactory创建SqlSession，用于执行SQL命令

●MyBatis接口方法SQL映射：XML和注解

 public interface MyMapper {
     @Select("SELECT * FROM users WHERE id = #{id}")
     User selectUser(@Param("id") int id);
 }

 <mapper namespace="com.example.MyMapper">
     <select id="selectUser" resultType="User">
         SELECT * FROM users WHERE id = #{id}
     </select>
 </mapper>

●MyBatis接口参数

 User selectUser(@Param("id") int id);

●MyBatis关联配置：对象关联、集合关联

 <resultMap id="userMap" type="User">
     <association property="address" column="address_id" select="selectAddress"/>
     <collection property="orders" column="user_id" select="selectOrders"/>
 </resultMap>

●MyBatis项目开发步骤

1. 添加依赖：在项目的构建配置文件中添加MyBatis和相关库的依赖。

2. 配置MyBatis：创建MyBatis的配置文件mybatis-config.xml，配置数据源和映射文件。

3. 定义SQL映射：编写SQL映射语句，可以通过XML或注解。

4. 编写DAO接口：定义数据访问接口。

5. 执行SQL：通过SqlSession或Mapper接口执行SQL命令。

6. 测试：编写和执行单元测试和集成测试。

●JPA/Hibernate核心接口对象及其作用

JPA（Java Persistence API）和Hibernate提供了以下核心接口对象：

1. EntityManager：用于管理实体类的持久化操作。

2. EntityTransaction：用于管理事务。

3. Query：用于执行查询操作。

4. CriteriaQuery：用于构建类型安全的查询。

●持久化对象的状态与生命周期

JPA/Hibernate中，持久化对象有几种状态：

1. 新建（New）：对象新创建，未被持久化。

2. 持久（Persistent）：对象已经被持久化，与数据库中的记录关联。

3. 游离（Detached）：对象曾经被持久化，但现在与EntityManager脱离。

4. 删除（Removed）：对象被标记为删除。

●JPA/Hibernate单表映射，双向1对多映射注解配置

●MyBatis与JPA/Hibernate实现ORM的比较

• SQL控制：MyBatis提供了更多的SQL控制，适合复杂SQL和优化。开发者可以直接编写SQL语句，对于理解数据库结构和优化查询性能非常有帮助。

• 易用性：JPA/Hibernate更加易用，提供了丰富的ORM功能，适合快速开发。它们提供了许多自动化的特性，如对象关系映射、事务管理、缓存等，减少了开发者的工作量。

• 灵活性：MyBatis更加灵活，因为它允许开发者自定义SQL和映射规则，适合需要对SQL语句进行精细控制的场景。而JPA/Hibernate虽然也提供了一定的灵活性，但其底层实现的复杂性可能会使得某些特殊需求的实现变得困难。

• 学习曲线：MyBatis相对简单，学习曲线较平缓，对于熟悉SQL的开发者来说，上手更快。JPA/Hibernate由于功能丰富，可能会有一个较陡的学习曲线。

• 性能：MyBatis因为可以手动编写SQL，所以能够进行更深入的优化，理论上可以获得更好的性能。JPA/Hibernate虽然提供了缓存和懒加载等性能优化特性，但其自动生成的SQL可能不是最优的。

• 适用场景：MyBatis适合于需要对数据库操作有精细控制的应用，尤其是复杂的业务逻辑和报表生成。JPA/Hibernate适合于需要快速开发和对ORM功能有较高要求的应用，尤其是企业级应用和CRUD密集型的项目。

SpringMVC

●Web MVC的演进

Web MVC（Model-View-Controller）是一种设计模式，用于将应用程序分为三个核心组件：模型（Model）、视图（View）和控制器（Controller）。这种模式最早由Trygve Reenskaug在1978年提出，用于Smalltalk-80语言。随着时间的推移，Web MVC被广泛采用在Web应用程序中，成为了一种标准的架构模式。

在Web应用的早期，大多数Web框架都是基于Servlet和JSP技术的。随后，像Struts这样的框架开始流行，它们提供了对MVC模式的支持。Spring MVC是在这些早期框架之后出现的，它提供了一个更加灵活和强大的MVC实现。

●Spring mvc的请求处理及响应的处理全流程

当一个HTTP请求到达Spring MVC应用程序时，以下流程会被触发：

1. 请求分发：请求首先被Spring的DispatcherServlet捕获。

2. URL映射：DispatcherServlet根据请求的URL找到对应的控制器（Controller）。

3. 控制器处理：控制器接收到请求，进行处理，并返回一个ModelAndView对象。

4. 数据绑定：如果请求包含数据（如表单数据），Spring MVC会自动将这些数据绑定到控制器方法的参数上。

5. 数据校验：在数据绑定之后，可以进行数据校验。

6. 业务逻辑处理：控制器可以调用业务逻辑层进行数据处理。

7. 视图渲染：控制器返回的ModelAndView对象会被用来渲染视图，生成HTML响应。

8. 响应返回：生成的响应会被发送回客户端。

●SpringMVC控制器的分类与作用

Spring MVC中的控制器可以分为两类：

1. 注解控制器：使用@Controller注解的类，用于处理HTTP请求。

2. REST控制器：使用@RestController注解的类，用于创建RESTful Web服务。

控制器的作用是接收用户的请求，处理这些请求，并返回相应的视图或数据。

●SpringMVC的URL映射

Spring MVC通过@RequestMapping注解或其变体（如@GetMapping、@PostMapping等）将URL映射到控制器的方法上。

 @RequestMapping("/example")
 public String example() {
     return "exampleView";
 }

●SpringMVC的参数绑定/命令对象属性绑定

Spring MVC支持自动将请求参数绑定到控制器方法的参数上。这可以通过在方法参数上使用@RequestParam、@PathVariable、@ModelAttribute等注解来实现。

 @GetMapping("/user/{id}")
 public String getUser(@PathVariable("id") Long id, Model model) {
     User user = userService.getUserById(id);
     model.addAttribute("user", user);
     return "userView";
 }

●SpringMVC参数数据校验

Spring MVC支持JSR 303/349校验规范，允许在控制器的方法参数上添加校验注解，如@NotNull、@Size等.

 @PostMapping("/user")
 public String createUser(@Valid @ModelAttribute User user, BindingResult result) {
     if (result.hasErrors()) {
         return "userForm";
     }
     userService.createUser(user);
     return "redirect:/users";
 }

●SpringMVC与servlet api

Spring MVC构建在Servlet API之上，但它提供了一个更高级的抽象层，使得开发者不需要直接与Servlet API交互。然而，如果需要，Spring MVC也允许直接访问Servlet API。

●SpringMVC的视图解析

Spring MVC使用视图解析器（View Resolver）来将控制器返回的逻辑视图名解析为实际的视图技术（如JSP、Thymeleaf等）。

●SpringMVC的json数据支持

Spring MVC支持将对象自动转换为JSON格式，这通常通过@ResponseBody注解或@RestController来实现。这需要配置适当的JSON序列化库，如Jackson或Gson。

●SpringMVC拦截器

Spring MVC允许注册拦截器（Interceptor），这些拦截器可以在请求处理的前后执行自定义逻辑。

preHandle：调用controller方法之前

postHandle：调用controller方法之后

afterCompletion：视图渲染完毕时

●SpringMVC文件上传

配置一下multipartResolver为bean

Spring MVC支持文件上传，这通常通过在控制器方法参数上使用@RequestParam MultipartFile注解来实现。

 @PostMapping("/upload")
 public String handleFileUpload(@RequestParam("file") MultipartFile file) {
     // 处理文件上传
     return "uploadSuccess";
 }

SSH整合

• SSH整合的基本思路

listen启动spring，spring启动dispatchservlet来启动springmvc，是父子容器

1. web.xml：

   • 定义DispatcherServlet，指定Spring MVC的上下文路径和初始化参数。

   • 定义Spring的监听器，用来启动Spring容器。

2. beans.xml：

   • 定义Spring容器中的Bean，包括数据源、事务管理器、DAO、Service等。

   • 配置MyBatis的会话工厂和事务管理器，以及包扫描。

3. mybatis.xml：

   • 定义MyBatis的配置，如数据库连接信息、方言、映射文件等。

   • 定义SQL映射语句和结果映射，以及驼峰等。

• 对MyBatis /JPA/Hibernate的整合

  首先要注意是spring与这两个整合，springmvc也与spring整合，但是和这两个没什么关系

  mybatis主要是sqlsessionfactory和datasource整合为bean与spring整合，配置mapper扫描器

  与jpa整合主要是datasource和entityManagerFactory整合，在dao中使用注入entityManager，然后将dao注入，类似于mapper

   @Repository 
   public interface UserDao extends JpaRepository<User, Long> {    *// 你可以添加自定义查询方法* }

  总结步奏

  1. 先注册数据源和factory为bean，

  2. 然后配置mapper和dao层，一个用@Mapper一个用@Repository，

  3. 不过mapper不用继承，dao需要注入entitymanager，因为jpa是通过拼凑的形式生成sql，所以需要继承一下

• Spring容器与SpringMVC容器的关系

Spring容器是Spring框架的核心，负责创建和管理应用程序中的Bean。SpringMVC容器是Spring容器的一个扩展，专门用于处理Web请求和响应。SpringMVC容器可以作为Spring容器的一个子容器，也可以独立存在。

• 整合后容器的启动配置

• SSH整合步骤

1. 创建项目：使用IDE创建一个新的Maven或Gradle项目。

2. 添加依赖：在项目的构建配置文件中添加SSH框架的依赖。

3. 配置数据库：配置数据库连接信息。

4. 创建实体类：创建Java实体类，用于映射数据库表。

5. 创建DAO接口：创建数据访问对象接口，定义数据访问方法。

6. 创建Service接口：创建业务逻辑对象接口，定义业务逻辑方法。

7. 实现DAO和Service接口：实现DAO和Service接口，使用MyBatis、JPA或Hibernate作为数据访问层。

8. 创建控制器：创建控制器类，使用Struts 2或其他MVC框架作为表现层。

9. 整合配置：在Spring配置文件中配置Struts 2、Hibernate和Spring的组件。

10. 启动和测试：启动整合后的容器，并进行测试。

• SSH架构的项目分析设计

• 项目结构

1. src/main/java：Java源代码目录，包含实体类、DAO接口、Service接口、控制器等。

2. src/main/resources：资源文件目录，包含配置文件、SQL映射文件等。

3. src/main/webapp：Web应用目录，包含Web应用的HTML、CSS、JavaScript等资源。

• 配置文件

1. pom.xml（Maven）或build.gradle（Gradle）：

   • 项目构建配置文件，定义了项目的依赖关系和构建过程。

   • 包含了SSH框架及其依赖的版本信息。

2. applicationContext.xml：

   • Spring容器配置文件，定义了Spring上下文中的组件，如数据源、事务管理器、DAO、Service等。

   • 配置了Hibernate的SessionFactory和事务管理器。

   • 配置了Struts 2的拦截器、结果映射等。

3. hibernate.cfg.xml：

   • Hibernate配置文件，定义了Hibernate的配置，如数据库连接信息、方言、映射文件等。

4. web.xml：

   • Web应用程序的部署描述符，定义了Web应用程序的部署信息，如Spring和Struts 2的监听器、过滤器等。

5. Spring的Java配置：

   • 除了XML配置文件，Spring也支持Java配置，使用@Configuration、@Bean等注解来定义组件。

6. MyBatis的XML配置：

   • 如果使用MyBatis作为数据访问层，还需要配置MyBatis的XML映射文件，用于定义SQL语句和结果映射。

• 各层开发与依赖注解