java 训练 ai 大模型 ai java开发

转载

mob64ca13fd163c 2023-10-23 23:51:33

文章标签 java 训练 ai 大模型 spring springmvc servlet j2ee 文章分类 Java 后端开发

文章目录

Servlet

Servlet容器
DefaultServlet：静态界面
Servlet原生HTML组装
JSP(Java Server Page)

Ajax(Asynchronous Javascript And XML)

Ajax代码Demo
浏览器展示

MVC开发框架

MVC概念
MVC代码框架

J2EE & JavaBeans
IOC & DI
SSH框架(Struts +Spring + Hibernate)
SSM框架(Spring + SpringMVC + Mybatis)

越来越大的Spring

Spring全家桶

很长时间没有接触到Web开发了，现在因为一些原因需要重新了解下Spring 全家桶，一下子对里面的一些概念有些陌生。本着学习任何技术都要从为什么开始学习的精神，慢慢的就梳理回到了自己最早接触的web开发内容，就想借着这篇文章将这次的回溯过程整理出来，形成自己的一种知识沉淀。

Servlet

在web世界里，一直就是存在着两个部分：前端浏览器 + 后台服务器，所谓的B/S架构：

前端负责显示。一般来说是指使用者电脑上的浏览器，浏览器根据HTML语言的标签定义的元素进行渲染。
后台负责准备数据。也就是根据业务逻辑准备前端需要渲染的内容。
中间的交互通过HTTP请求来传递。这篇文章不解释HTTP，HTTP请求相关的可以参考：

作为一个前后台开发者，大部分关心的是服务器程序这边的东西。

服务器程序是作为一个常驻的服务存在，为HTTP请求服务，再返回给前端浏览器。服务器程序在逻辑上完成了下面几件事情：

解析HTTP请求报文，组装成HttpRequest的对象。服务器内部的进程可以直接使用。
封装HTTP相应报文，将HttpResponse对象封装成一份满足HTTP协议要求的报文。
完成业务逻辑。
管理Session等其他任务。

典型的一个web应用结构如图所示：

java 训练 ai 大模型 ai java开发_spring

其中：

Servlet容器完成了HTTP请求和响应的解析和封装。
Servlet实例完成HTTP请求到响应的逻辑执行。这部分代码逻辑的部分就是Servlet实例，放在Java体系中来看就是一个Java类。

Servlet容器

也就是说，Servlet容器完成的就是上面所说HTTP请求的解析和封装过程 (另外还有一个概念是CGI，这里不细谈了)。而Servlet实例部分就是承载业务逻辑的部分。而两者合一就可以作为一个web服务器存在了，现在市面上的web服务器产品基本都是包含了这两个部分，比如tomcat，JBOSS，weblogic等。

以Tomcat为例，通过配置Servlet来看下，Servlet容器干了点啥

打开conf/web.xml。

首先是通过标签定义服务器中有的servelt种类，这里可以用服务器自带的，比如

<servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
    </servlet>

再通过标签定义这些servlet的使用方式。

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

<!-- The mappings for the JSP servlet -->
<servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.jsp</url-pattern>
    <url-pattern>*.jspx</url-pattern>
</servlet-mapping>

也就是除了URL里面jsp和jspx结尾的使用JspServlet，其他都使用默认的Servlet。

DefaultServlet：静态界面

看一下一个简单的HelloWorld静态界面的Servlet服务过程。

HTML代码如下：

<html>

  <head>

    <title>Static Page</title>

  </head>

  <body>

    <h1>Hello World</h1>

  </body>

</html>

Servlet实例通过URL定位到资源所在，然后将资源加载好之后，赋值到HTTPResponse中，返回给浏览器。

浏览器上就可以得到这个内容了：

java 训练 ai 大模型 ai java开发_springmvc_02

java 训练 ai 大模型 ai java开发_springmvc_03

Servlet原生HTML组装

如果是直接自定义HttpServlet的话，重载其doGet函数就会是：

public void doGet(HttpServletRequest request,HttpServletResponse)
   throws IOException,ServletException
{
    response.setContentType("text/html;charset=gb2312");
    PrintWriter out = response.getWriter();
    out.println("<html>");
    out.println("<head><title>Hello World！</title></head>");
    out.println("<body>");
    out.println("<p>Hello World！</p>");
    out.println("</body></html>");
}

这个很明显是不现实的，那么我们可以把这部分out.println的代码抽取出来用可复用的代码逻辑来实现，这就是JSP的方式。

JSP(Java Server Page)

接上一节，如果我想在界面上展示一些有点个性化的东西，比如根据每个访问用户都展示不一样的东西。

其中一个思路就是直接把这个业务逻辑写道服务器的资源文件里，由Servlet解析后生成不同的html页面来返回给前台浏览器。在java体系中这个技术方案就是JSP。

JSP代码如下：

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

<!DOCTYPE html>

<html>   

  <head>

        <meta charset="utf-8">

    <title>Java Server Page</title>

  </head>



  <body>

    Hello World!<br />

    <% out.println("your IP is " + request.getRemoteAddr());%>

  </body>

</html>

上一节讲到的，tomcat提供了jsp的Servlet解析器。Servlet实例找到jsp资源后，使用JspServlet进行资源的加载。在加载的过程中，会将其中的java代码进行编译和执行，再生成html内容封装到HTTPResponse里返回给客户端。

于是，在客户端浏览器看到的内容就是执行后的内容了：

java 训练 ai 大模型 ai java开发_spring_04

当然，这个代码还是在JSP文件里，这个可以单独成一个JavaBeans的类来共JSP文件调用。JavaBeans在后面和J2EE一起会提到。

Ajax(Asynchronous Javascript And XML)

JSP已经可以解决根据请求内容来确认不同的界面内容了，但是存在的一个问题是，浏览器每次都要全部加载一次的HTML上的内容，如果是纯文本的内容的话，问题不大。但是随着互联网展示的内容越来越多，一个界面会有大量的图像和视频内容，每次都加载显然是不合算的。而且每次定制化的界面，大部分是相同的，只有部分是相同的，通过点击某些按钮实现的界面切换也是同样的道理，只需要更新某个界面区域就可以了。这个时候，Ajax跳出来解决了这个问题。

在Ajax出来之前，界面加载和显示是一个同步串行的过程：

java 训练 ai 大模型 ai java开发_servlet_05

这样的效果就是每次跳转等待下一个界面时，整个浏览器界面都是会进行刷新。需要加载界面所有的信息，不管页面1和页面2有多少相同的部分。

而我们的目的是：如何页面1和页面2大部分内容相同的话，比如页面1是一个购物车，我点击某件商品的加1按钮，实际上我只需要刷新数量框和总价部分即可，因为总价需要和服务器进行交互(满X减X的活动需要和服务器交互获得数据)。而如果是同步加载界面的话，整个界面都需要刷新，明显的不划算。

下面是我理解的AJAX解决这个问题的逻辑：

第一步的话就是将显示和数据同步两个过程从同步串行的关系改成异步，浏览器可以一直显示某个界面，数据一旦同步完成之后，由“数据同步”完成这个事件来驱动界面进行刷新。这样就可以避免页面2加载的时候因为网络故障直接出现404的错误等。
第二步就是需要将界面拆成若干个元素进行操作。HTML标签本身是一个树状结构，于是引入了DOM将整个HTML文档组成成一个对象：XMLHttpRequest对象。
JavaScript对DOM进行操作，样式通过CSS显示。
通过onreadystatechange 回调函数来通知浏览器进行界面渲染，浏览器通过修改DOM对象的某个成员从而达到修改部分界面效果的目的。

上面几部分内容组合在一起就形成了一个整个前后台交互过程中的一个新的“层”：Ajax引擎。

java 训练 ai 大模型 ai java开发_spring_06

Ajax代码Demo

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script>
function loadXMLDoc()
{
	var xmlhttp;
	if (window.XMLHttpRequest)
	{
		//  IE7+, Firefox, Chrome, Opera, Safari 浏览器执行代码
		xmlhttp=new XMLHttpRequest();
	}
	else
	{
		// IE6, IE5 浏览器执行代码，IE总是与众不同，它有自己的Ajax引擎
		xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
	}
	xmlhttp.onreadystatechange=function()
	{
        // 定义回调函数
		if (xmlhttp.readyState==4 && xmlhttp.status==200)
		{
            // 将请求到的内容封装到了responseText成员中，Ajax引擎执行了这个封装过程，当然也可以自己来解析
			document.getElementById("myDiv").innerHTML=xmlhttp.responseText;
		}
	}
    //发送资源GET请求
	xmlhttp.open("GET","./ajax_info.txt",true);
	xmlhttp.send();
}
</script>
</head>
<body>


<div id="myDiv"><h2>使用 AJAX 修改该文本内容</h2></div>

<button type="button" onclick="loadXMLDoc()">修改内容</button>

</body>
</html>

当然，这个是比较原生的写法了，现在支持各种ajax的语法，但是逻辑上是一致的。

浏览器展示

总共两次请求：

java 训练 ai 大模型 ai java开发_spring_07

第一次是将上面的HTML文件资源下载到服务器。

点击按钮后，根据ajax代码，去请求同一目录下的ajax_info.txt资源。

java 训练 ai 大模型 ai java开发_spring_08

最终浏览器通过documet这个DOM对象刷新掉"myDiv"这个元素显示的内容。

我自己理解ajax主要是需要浏览器上的支持。

MVC开发框架

MVC概念

Servlet与Ajax两样基本上可以解决很多问题了，但是随着界面业务越来越复杂。所有的业务基本上都是写在HTML资源或者JSP里，导致的一个问题是样式设计和业务逻辑全部搅在一起，样式设计可能是UI，美工；业务逻辑是程序员，互相看不懂，导致开发效率下降。因此，模块化这部分内容就成了一个急需解决的问题，大名鼎鼎的MVC模式就是解决这个问题的。

从网上COPY了一张图过来，典型的MVC模型结构：

java 训练 ai 大模型 ai java开发_java 训练 ai 大模型_09

MVC是一种设计理念或者模式。每个IT从业人员都会对MVC有自己的理解，这里我讲一讲我自己的理解。

MVC是基于低耦合-高内聚的模块化设计
M(Model，模型)指的是业务模型。软件系统一般是为了某种现实中的业务场景服务，而这里的模型指的就是抽象出来的业务模型结构。比如是一个计费系统，那么从计费业务中可以抽象出客户，账户，账单，账期等等业务模型。在代码中更多的就是抽象成一张一张的数据库表和对应的值对象(Value Object, VO)、以及对应值对象的数据库访问对象(Data Access Object，DAO)。
V(View，视图)指的是界面显示内容。也就是说界面显示逻辑，同样的数据模型在界面上可能会有多种显示方式。
C(Controller，控制器)。控制器连接模型和视图，将模型经过某种逻辑装换在某个视图中展示出来。或者是将视图上的交互内容通过某种逻辑转换形成数据模型再持久化。
MVC只是一种设计和编码理念，不是强制性要求。也就是说你非要把业务处理逻辑写在你的DAO类中，也无所谓，就是看着不那么舒服，维护起来更麻烦一点而已。
MVC模式和其他设计模式不冲突，不是一个并行的关系，而是一个互相融合的关系。

MVC代码框架

J2EE & JavaBeans

在说SSM之前，想先提一下J2EE和JavaBeans。

J2EE是Sun公司提出的商业系统的体系结构和标准。

java 训练 ai 大模型 ai java开发_springmvc_10

从图中可以看出，J2EE是想试图从web系统的全流程：浏览器(B端)到服务器端(S端)提供完整的解决方案。

其中客户端的Java Applet已经成为了历史，现在基本没有人在web系统里采用applet来开发。EJB也因为其复杂程度而被弃用了。

在这里提一下J2EE的目的是后面很多的理念都是从J2EE演变或者简化而来，我自己对J2EE和后面Spring的关系理解是对比是网络中的OSI七层模型和TCP/IP4层模型的关系。

一个是想设计一套大而全的方案，但是市场不买账。
一个是小而美的使用方案，被市场迅速接受而推广起来。

Javabeans是EJB中满足J2EE标准的JAVA类：

该Java类必须包含没有任何参数的构造函数。例如，一个Student类，则这个类必须包含public Student()这个不带参数的构造函数。
该类需要实现java.io.Serializable接口。实现了Serializable接口的对象可以转换为字节序列，这些字节序列可以完全存储以备重新生成原来的对象。
该类必须要有属性接口。也就是说，每个属性都要有get和set的属性操作方法。例如描述一个学生的类Student，其中有属性名Name，那么这个类中必须同时包含getName()和setName()这两个方法。

javabeans是整套方案的基础，每个层次的解决方案，类似JSP，EJB的方案都是以javabeans作为基础来设计和开发的。

另外，J2EE体系架构里还提到了很多后续推广和使用范围很广的概念，比如JDBC，JNDI，XML，JMS，JTA等等。所以我理解J2EE为后续的web系统开发提供了大而全的体系参考，每种流形的web开发框架多多少少参考了这套体系结构，因此我觉得还是有必要了解下web开发的最初体系：J2EE。

IOC & DI

大名鼎鼎的IOC（控制反转）和DI（依赖注入）是这些框架实现MVC配置化的基础，

所谓的IoC控制反转的解释我是这么理解的：在程序的控制流程中都是由代码来控制类的依赖，比如在程序中编写：

Class_A a = new Class_A();

这样，编译器就知道在运行期间将Class_A的所有依赖加载到内存中。也就是说依赖先与运行环境确定，也可以说是依赖控制运行环境的内容。而控制反转是指由运行过程或者环境来控制依赖。也就是运行的时候根据运行情况来加载依赖项；或者说，本来属于java程序里构建对象的功能交由容器接管，依赖注入就是当程序要使用某个对象时候，容器会把它注入到程序里，这就叫做依赖注入DI。

后面打算针对JAVA虚拟机琢磨下底层的实现机制。

上面提到的这个IOC控制一般由WEB开发框架来实现，其中Spring Framework就是其中的佼佼者。基本上都是通过xml配置来实现IOC和MVC模式的实现。

SSH框架(Struts +Spring + Hibernate)

Struts现在基本上已经被弃用了，但是作为红极一时的框架，还是有必要了解一下的，也可以知道它为什么被淘汰。

struts是基于MVC设计模式，利用Servlet/JSP/JavaBeans这些已有技术合在一起的开发框架。

结构图如下：

java 训练 ai 大模型 ai java开发_springmvc_11

Struts在Servlet容器中增加了一个过滤器(Filter)来拦截URL请求：
在web.xml（Servlet容器配置）中配置过滤器:

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name>Struts1</display-name>
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>*.action</url-pattern>
  </filter-mapping>
</web-app>

这个过滤器的作用就是拦截Servlet请求，拦截之后读取核心配置文件struts.xml，来选择合适action。

java 训练 ai 大模型 ai java开发_spring_12

看看作为MVC模式中的关键部分Controller，在Struts框架中叫做Action。

struts中的Action：

<action name="login" class="com.oumyye.action.LoginAction">
             <result name="success">/success.jsp</result>
         </action>

其中的class就是执行Controller任务的JAVA类

sucess.jsp就是负责展示的View

在Action类中可以访问DAO，这块的内容就是Hibernate的活了。其中的ORM模型基本上就是一个javabeans(只有set/get方法的类)对应一张数据表。再通过hibernate.cfg.xml文件配置每个javabeans，或者说某张表的增删改查SQL。
Spring框架在这个过程中主要就是提供IoC和AOP功能的支持。比如上面在容器的运行环境中根据struts的配置来加载依赖项，就是需要IOC/DI的支持。
spring又要配置一个applicationContext.xml文件。比如上面需要一个action类：LoginAction

<beans>

	*<!-- 定义一个业务逻辑组件，实现类为MyServiceImp -->*

		<bean id="loginAction" class="com.oumyye.action.LoginAction"scope="prototype" />

<beans>

这里就是将这个LoginAction类标记一下，交给IoC容器去进行管理，如果有id=loginAction的容器需要创建，就调用com.oumyye.action.LoginAction的类进行创建。

SSM框架(Spring + SpringMVC + Mybatis)

SSH火了一段时间之后，Spring越做越大，出了自己的MVC，也就是除了自己做了IOC，AOP功能，把上面提到的Struts的活也给抢了。一个产品被替换掉有各种各样的原因，不一定是技术本身的原因。所以我只是从自身使用的角度去理解一下两者的区别：

还是先搬一张SpringMVC的架构图：

java 训练 ai 大模型 ai java开发_j2ee_13

Struts基于拦截器，SpringMVC基于Servlet本身，称作前端控制器(DispatcherServlet)，基于Servlet的从应用的时间线上来说覆盖度更大。SpringMVC的后续所有操作都是基于这个前端控制器：Dispatcher
直接在web.xml里定义了一个新的Servlet(Struts是定义了一个filter)：

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

<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>  //处理所有请求
</servlet-mapping>

SpringMVC基于反射，Struts基于回调。我个人感觉这个区别不大，可能在安全层面有区别吧，自己不了解的东西不说。
从DispatcherServlet出来之后，会根据URL请求类型来匹配不同的Handler。作用上和上面提到的Struts是类似的，但是Spring做的更精细，来看一下这个匹配过程。
先放一个典型的配置文件，在WEB-INF目录下游一个[Servlet-name]-servlet.xml的配置文件，这个就是为了某个SpringMVC Servlet提供匹配规则的配置文件：
比如Dispatcher-servlet.xml(和Struts.xml中的action配置类似)：

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="simpleUrlHandlerMapping"
          class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <!-- /hello 路径的请求交给 id 为 helloController 的控制器处理-->
                <prop key="/hello">helloController</prop>
            </props>
        </property>
    </bean>
    <bean id="helloController" class="controller.HelloController"></bean>
</beans>

根据配置文件就是可以得到上面架构图中的通过HandlerMapping得到需要执行的Handler类。

处理/hello这个URL路径的请求的Controller类就是HelloController：

package controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class HelloController implements Controller {

    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mav = new ModelAndView("index.jsp");
        mav.addObject("message", "Hello Spring MVC");
        return mav;
    }
}

代码中返回了控制器控制的模型(M)和相关视图(V)，SpringMVC中提供了这样一个类：ModelAndView。

从代码中可以看出来，ModelAndView也是基于JSP为View的方式。在上面的HelloWorld代码中，使用的就是index.jsp作为/hello这个URL请求的显示界面。在把ModelAndView对象中的View展示给浏览器的过程中，需要用到ViewResolver和View对象。
在ModelAndView对象中，只包含了一个逻辑视图名，也就是只知道index.JSP来做展示。那么ViewResolver的作用就是找到逻辑视图名，然后将资源文件解析成可用于展示的View对象。有不同的解析器，针对同一个逻辑视图名会有不同的解析方式：

java 训练 ai 大模型 ai java开发_springmvc_14

每种视图解析器获得的View都不同，但都是实现了View接口的类或者子类。

具体使用哪个视图解析器是通过配置来实现。

[servlet-name]-servlet.xml：

<bean id="test" class="org.springframework.web.servlet.view.InternalResourceView">  
   <property name="url" value="/index.jsp"/>  
</bean>

而View接口主要就是render方法，每个实现类或者子类都不一样：

public interface View {
    String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
    String PATH_VARIABLES = View.class.getName() + ".pathVariables";
    String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";

    @Nullable
    default String getContentType() {
        return null;
    }

    void render(@Nullable Map<String, ?> var1, HttpServletRequest var2, HttpServletResponse var3) throws Exception;
}

也就是确定如何生成HttpServletResponse，以便于浏览器可以根据响应来进行渲染。

数据层，或者说Model是通过mybatis来实现，mybatis也是实现了jdbc接口的框架。个人感觉和Hibernate区别不大。
上面的整套流程下来是不是发现没有用到HandlerAdater？回过头看下dispatcher-servlet.xml中的beans中配置的mapping映射器SimpleUrlHandlerMapping，可以去这个包下看下，还有一堆的其他的mapping：

java 训练 ai 大模型 ai java开发_java 训练 ai 大模型_15

这个下面以Mapping结尾的都是。可以针对不同的路径配置不同的mapping映射器。每种映射器返回的Handler种类是不一样的。AbstractUrlHandlerMapping 映射器映射出来的是 handler 是 Controller 对象，AbstractHandlerMethodMapping 映射器映射出来的 handler 是 HandlerMethod 对象。

针对不同的Handler对象选择不同Handler执行器来执行，中间就是差一个适配器Adapter了，于是，适配器设计模式就派上用场了，各种各样的Adapter就是用于衔接这个中间过程的。

applicationContext.xml这个文件没啥用，直接用springMVC的可以不用。
最好用的功能：注解代替配置。我一直觉得这个功能解放了很多在各种配置xml中来回折腾的程序员。一个@RequestMapping、@Controller就可以代替一条配置，不需要在xml和java文件中来回比对，节省了不少工作量。

总的来说，SpringMVC相比Struts拆分的更细，可控制的内容更多更细致，支持更多的配置，更加的灵活，再加上注解配置和Spring自家支持的IoC，AOP支持，咋不得性能更高？所以就把Struts干掉，自己一统天下了。

越来越大的Spring

在SSM框架一统江湖的时候，Spring团队针对现在越来越火的微服务，又祭出了牛逼的框架Spring Boot & Spring Cloud。

在SSM框架中，启动一个应用最基本的几个配置工作是：

配置web.xml，加载spring和spring mvc；
配置数据库连接、配置spring事务；
配置加载配置文件的读取，开启注解；
配置日志文件；
配置完成之后部署tomcat 调试；
各种各样的依赖包互相打架，要找到一套互相兼容的依赖包也是费时费劲的工作。

如果有一个工具出来把这些都简化了，不需要配置，不需要找各种各种的依赖包来凑到一起，就问你香不香？这就是Spring Boot。

从字面意思上去理解Spring Boot，可以理解成把Spring Framework里面的各种依赖做成了更方便启动的引导系统，类似于操作系统里的Boot启动系统。而承载这个功能的就是各种各样的starter。

java 训练 ai 大模型 ai java开发_servlet_16

一个SpringBoot项目里的pom文件里配置的依赖项，和web相关的基本上就浓缩成一个配置：

Spring官方的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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starters</artifactId>
		<version>1.5.17.RELEASE</version>
	</parent>
	<artifactId>spring-boot-starter</artifactId>
	<name>Spring Boot Starter</name>
	<description>Core starter, including auto-configuration support, logging and YAML</description>
	<url>http://projects.spring.io/spring-boot/</url>
	<organization>
		<name>Pivotal Software, Inc.</name>
		<url>http://www.spring.io</url>
	</organization>
	<properties>
		<main.basedir>${basedir}/../..</main.basedir>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-autoconfigure</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-logging</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<exclusions>
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.yaml</groupId>
			<artifactId>snakeyaml</artifactId>
			<scope>runtime</scope>
		</dependency>
	</dependencies>
</project>

再配上@SpringBootApplication、@EnableAutoConfiguration、@ComponentScan等核心注解，就达到了SpringBoot快速配置和启动的目的。

SpringBoot还内置了jetty，tomcat等容器，连配置容器的工作都省了。

Spring全家桶

Spring慢慢的将自己的生态扩到了web开发的方方面面，其实不止web开发，但是web开发现在比较火热嘛。在

可以查到所有的Spring开源项目。

支持所有数据访问的Spring Data，可以针对mongodb，redis等数据存储。
针对微服务的Spring Cloud。
针对安全的Spring Security等等。
这些就后续有机会了再一个一个说吧，这一篇已经把我之前接触和使用过的相关的Java Web开发内容全部整理了一遍。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：交付架构师的优势些什么交付支持工程师

下一篇：android 设置window宽高 android on windows

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯