Java|JAVAWEB框架知识点总结 spring|boot|后端|java

目录
JAVAWEB框架常用知识点总结
1.Struts2框架
1.1 struts2请求原理
1.2struts2与jsp传参交互方式
2.springmvc
2.1架构
2.2 SpringMVC与页面交互的几种方法
2.3SpringMVC与Struts2的主要区别？
3.Spring框架
3.1.架构
3.2 IOC介绍
3.3Spring基于XML装配Bean
3.4Spring基于注解装配Bean

4.mybatis和hibernate区别
5.springboot
6.Springcloud
JAVAWEB框架常用知识点总结编写日期：2021.6.6
作者：会跳舞的程序员（jelly）
备注：会持续更新完善

目录
JAVAWEB框架常用知识点总结
1.Struts2框架
1.1 struts2请求原理
1.2struts2与jsp传参交互方式
2.springmvc
2.1架构
2.2 SpringMVC与页面交互的几种方法
2.3SpringMVC与Struts2的主要区别？
3.Spring框架
3.1.架构
3.2 IOC介绍
3.3Spring基于XML装配Bean
3.4Spring基于注解装配Bean
3.5Spring源码
4.mybatis和hibernate区别
5.springboot
6.Springcloud

1.1 struts2请求原理
1.2struts2与jsp传参交互方式
2.springmvc
2.1架构
2.2 SpringMVC与页面交互的几种方法
2.3SpringMVC与Struts2的主要区别？
3.Spring框架
3.1.架构
3.2 IOC介绍
3.3Spring基于XML装配Bean
3.4Spring基于注解装配Bean
4.mybatis和hibernate区别
5.springboot
【Java|JAVAWEB框架知识点总结】
1.Struts2框架 1.1 struts2请求原理
文章图片

（1）客户端发出HTTP请求

（2）然后请求被核心过滤器StrutsPrepareAndExecuteFilter拦截

（3）核心过滤器将请求转发到Action映射器，Action映射器负责识别当前的请求是否需要交由Struts2处理。

（4）Action映射器返回需要struts2处理的信息，StrutsPrepareAndExecuteFilter会创建一个Action代理

（5）Action代理并不知道执行哪一个Action，它会向配置管理器询问调用哪一个Action，配置管理器会从struts.xml读取我们配置的Action信息。

（6）Action代理创建相关请求的Action对象，调用相关的方法之前，struts2的一系列拦截器会帮我们做一些操作，例如获取请求参数等。

（7）然后调用execute方法根据返回的字符串去匹配相应的页面，

（8）页面可以获取一些页面模板，然后生成最终页面，再倒序的执行拦截器的后续操作

（9）最后生成HTTP响应内容
1.2struts2与jsp传参交互方式
1.通过request对象来获取：
前端页面：

文章图片

struts action：

文章图片

struts 配置文件：

文章图片

2.通过Action的属性的set方法注入，struts会通过表单字段的名称，调用set方法，比如username字段会调用setUsername
struts action：

文章图片

前端代码和配置文件和第一种方法相同，就不一一展示了

4.通过Action的属性的set模型的形式注入，即：创建一个模型类（实体类），将参数存入模型内
实体类

文章图片

前端页面：

文章图片

struts action：

文章图片

2.springmvc 2.1架构
文章图片

1.用户发送请求至前端控制器DispatcherServlet。
2.前端控制器DispatcherServlet收到请求后调用处理器映射器HandlerMapping。
3.处理器映射器HandlerMapping根据请求的Url找到具体的处理器，生成处理器对象Handler及处理器拦截器HandlerIntercepter（如果有则生成）一并返回给前端控制器DispatcherServlet。
4.前端控制器DispatcherServlet通过处理器适配器HandlerAdapter调用处理器Controller。
5.执行处理器（Controller，也叫后端控制器）
6.处理器Controller执行完后返回ModelAnView。
7.处理器映射器HandlerAdapter将处理器Controller执行返回的结果ModelAndView返回给前端控制器DispatcherServlet。
8.前端控制器DispatcherServlet将ModelAnView传给视图解析器ViewResolver。
9.视图解析器ViewResolver解析后返回具体的视图View。
10.前端控制器DispatcherServlet对视图View进行渲染视图（即：将模型数据填充至视图中）
11.前端控制器DispatcherServlet响应用户。
2.2 SpringMVC与页面交互的几种方法常用的方式
method（int name）
Useruser
request
2.3SpringMVC与Struts2的主要区别？ ①springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。
②springmvc是基于方法开发，传递参数是通过方法形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。

③Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数解析器是将request对象内容进行解析成方法形参，
将响应数据和页面封装成ModelAndView对象，最后又将模型数据通过request对象传输到页面。 Jsp视图解析器默认使用jstl。
3.Spring框架 3.1.架构
文章图片

1. Data Access/Integration（数据访问／集成）
数据访问/集成层包括 JDBC、ORM、OXM、JMS 和 Transactions 模块，具体介绍如下。

JDBC 模块：提供了一个 JDBC 的抽象层，大幅度减少了在开发过程中对数据库操作的编码。
ORM 模块：对流行的对象关系映射 API，包括 JPA、JDO、Hibernate 和 iBatis 提供了的集成层。
OXM 模块：提供了一个支持对象/XML 映射的抽象层实现，如 JAXB、Castor、XMLBeans、JiBX 和 XStream。
JMS 模块：指 Java 消息服务，包含的功能为生产和消费的信息。
Transactions 事务模块：支持编程和声明式事务管理实现特殊接口类，并为所有的 POJO。

2. Web 模块
Spring 的 Web 层包括 Web、Servlet、Struts 和 Portlet 组件，具体介绍如下。

Web 模块：提供了基本的 Web 开发集成特性，例如多文件上传功能、使用的 Servlet 监听器的 IoC 容器初始化以及 Web 应用上下文。
Servlet模块：包括 Spring 模型—视图—控制器（MVC）实现 Web 应用程序。
Struts 模块：包含支持类内的 Spring 应用程序，集成了经典的 Struts Web 层。
Portlet 模块：提供了在 Portlet 环境中使用 MV C实现，类似 Web-Servlet 模块的功能。

3. Core Container（核心容器）
Spring 的核心容器是其他模块建立的基础，由 Beans 模块、Core 核心模块、Context 上下文模块和 Expression Language 表达式语言模块组成，具体介绍如下。

Beans 模块：提供了 BeanFactory，是工厂模式的经典实现，Spring 将管理对象称为 Bean。
Core 核心模块：提供了 Spring 框架的基本组成部分，包括 IoC 和 DI 功能。
Context 上下文模块：建立在核心和 Beans 模块的基础之上，它是访问定义和配置任何对象的媒介。ApplicationContext 接口是上下文模块的焦点。
Expression Language 模块：是运行时查询和操作对象图的强大的表达式语言。

4. 其他模块
Spring的其他模块还有 AOP、Aspects、Instrumentation 以及 Test 模块，具体介绍如下。

AOP 模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。
Aspects 模块：提供与 AspectJ 的集成，是一个功能强大且成熟的面向切面编程（AOP）框架。
Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
Test 模块：支持 Spring 组件，使用 JUnit 或 TestNG 框架的测试。

3.2 IOC介绍 spring 提供了两种 IoC（控制反转）容器，分别为 BeanFactory 和 ApplicationContext。由原来具体类中创建对象，现在创建对象交给容器进行管理
3.3Spring基于XML装配Bean 1）属性 setter 注入
指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后，调用该 bean 的 setter 方法，即可实现基于 setter 的 DI。
2）构造方法注入
指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法实现，每个参数代表一个依赖。

下面通过属性 setter 注入的案例演示 Spring 容器是如何实现依赖注入的。具体步骤如下。

?xml version="1.0" encoding="UTF-8"?>

3.4Spring基于注解装配Bean 1）@Component
可以使用此注解描述 Spring 中的 Bean，但它是一个泛化的概念，仅仅表示一个组件（Bean），并且可以作用在任何层次。使用时只需将该注解标注在相应类上即可。
2）@Repository
用于将数据访问层（DAO层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
3）@Service
通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
4）@Controller
通常作用在控制层（如 Struts2 的 Action），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
5）@Autowired
用于对 Bean 的属性变量、属性的 Set 方法及构造函数进行标注，配合对应的注解处理器完成 Bean 的自动配置工作。默认按照 Bean 的类型进行装配。
6）@Resource
其作用与 Autowired 一样。其区别在于 @Autowired 默认按照 Bean 类型装配，而 @Resource 默认按照 Bean 实例名称进行装配。
实例
1. 创建 DAO 层接口
在 src 目录下创建一个名为 com.mengma.annotation 的包，在该包下创建一个名为 PersonDao 的接口，并添加一个 add() 方法，如下所示。

package com.mengma.annotation;

public interface PersonDao {

public void add();

}

2. 创建 DAO 层接口的实现类
在 com.mengma.annotation 包下创建 PersonDao 接口的实现类 PersonDaoImpl，编辑后如下所示。

package com.mengma.annotation;

import org.springframework.stereotype.Repository;

@Repository("personDao")

public class PersonDaoImpl implements PersonDao {

@Override

public void add() {

System.out.println("Dao层的add()方法执行了...");

}

}

上述代码中，首先使用 @Repository 注解将 PersonDaoImpl 类标识为 Spring 中的 Bean，其写法相当于配置文件中的书写。然后在 add() 方法中输出一句话，用于验证是否成功调用了该方法。
3. 创建 Service 层接口
在 com.mengma.annotation 包下创建一个名为 PersonService 的接口，并添加一个 add() 方法，如下所示。

package com.mengma.annotation;

public interface PersonService {

public void add();

}

4. 创建 Service 层接口的实现类
在 com.mengma.annotation 包下创建 PersonService 接口的实现类 PersonServiceImpl，编辑后如下所示。

package com.mengma.annotation;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

@Service("personService")

public class PersonServiceImpl implements PersonService {

@Resource(name = "personDao")

private PersonDao personDao;

public PersonDao getPersonDao() {

return personDao;

}

@Override

public void add() {

personDao.add(); // 调用personDao中的add()方法

System.out.println("Service层的add()方法执行了...");

}

}

上述代码中，首先使用 @Service 注解将 PersonServiceImpl 类标识为 Spring 中的 Bean，其写法相当于配置文件中的书写。

然后使用 @Resource 注解标注在属性 personDao 上（也可标注在 personDao 的 setPersonDao() 方法上），这相当于配置文件中的写法。最后在该类的 add() 方法中调用 personDao 中的 add() 方法，并输出一句话。
5. 创建 Action
在 com.mengma.annotation 包下创建一个名为 PersonAction 的类，编辑后如下所示。

package com.mengma.annotation;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;

@Controller("personAction")

public class PersonAction {

@Resource(name = "personService")

private PersonService personService;

public PersonService getPersonService() {

return personService;

}

public void add() {

personService.add(); // 调用personService中的add()方法

System.out.println("Action层的add()方法执行了...");

}

}

上述代码中，首先使用 @Controller 注解标注 PersonAction 类，其写法相当于在配置文件中编写。

然后使用了 @Resource 注解标注在 personService 上，这相当于在配置文件内编写。

最后在其 add() 方法中调用了 personService 中的 add() 方法，并输出一句话。
6. 创建 Spring 配置文件
在 com.mengma.annotation 包下创建一个名为 applicationContext.xml 的配置文件，如下所示。

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-2.5.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

与之前的配置文件相比，上述代码的元素中增加了第 7 行、第 15 行和第 16 行中包含有 context 的代码，然后在第 18 行代码中，使用 context 命名空间的 component-scan 元素进行注解的扫描，其 base-package 属性用于通知 spring 所需要扫描的目录。
7. 创建测试类
在 com.mengma.annotation 包下创建一个名为 AnnotationTest 的测试类，编辑后如下所示。

package com.mengma.annotation;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AnnotationTest {

@Test

public void test() {

// 定义Spring配置文件路径

String xmlPath = "com/mengma/annotation/applicationContext.xml";

// 初始化Spring容器，加载配置文件，并对bean进行实例化

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

xmlPath);

// 获得personAction实例

PersonAction personAction = (PersonAction) applicationContext

.getBean("personAction");

// 调用personAction中的add()方法

personAction.add();

}

}

上述代码中，首先通过加载配置文件并获取 personAction 的实例，然后调用该实例的 add() 方法。

4.mybatis和hibernate区别 mybatis：入门简单，程序容易上手开发，节省开发成本。mybatis需要程序员自己编写sql语句，是一个不完全的ORM框架，对sql修改和优化非常容易实现。
mybatis适合开发需求变更频繁的系统，比如：互联网项目。

hibernate：入门门槛高，如果用hibernate写出高性能的程序不容易实现。hibernate不用写sql语句，是一个 ORM框架。
hibernate适合需求固定，对象数据模型稳定，中小型项目，比如：企业OA系统

5.springboot 1.springboot框架背景
原有JAVAWEB框架：配置繁琐、jar包版本多、依赖复杂、日志性能监控程度低等，所以有了springboot框架发展，springboot使用@springbootapplication注解解决此问题
2.@springbootapplication介绍
包含了@springbootconfiguration（配置类）、@enableautoconfiguration（自动配置）@componSon（自动扫描）三个注解
1）@springbootconfiguration案例
原有配置数据库连接池用xml方式进行配置

springboot提供方式（autowired方式、构造方式、bean方式）
案例（autowired方式）

1.创建application.yml文件jdbc.url=xxxxx jdbc.username=xxxxx 2.创建jdbcProperty.class@ConfigurationProperties（“jdbc”） publiceclass jdbcProperty {privateString url; 此处省略get/set方法} 2.创建jdbcConfiguration.class @configuration @EnableautoconfigurationProperties（"dbcProperty.class"） public class jdbcConfiguration {@Aotowired private JdbcConfiguration jdbc；@bean publicDatasoucedataSouce {DatasoucedataSouce=new XXDatasouce dataSouce.setUrl(jdbc.getUrl)retrundataSouce}}

2）@Enableautoconfiguration案例
Springboot预先对一些默认进行常用配置，是否开启自动配置，看否对该配置进行依赖
3）@ComponSon案例
不需要进行在xml配置自动扫描组件配置
6.Springcloud SpringCloud也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括：