程序员经验分享-hwhale

SpringMVC设计模式

2023-05-16

什么是MVC


        MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。是将业务逻辑、数据、显示分离的方法来组织代码。MVC主要作用是降低了视图与业务逻辑间的双向偶合。MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

  • Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
  • View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
  • Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

SpringMVC

图片.png

运行步骤： 

1、用户发起恩恩请求URL到达前端控制器

2、前端控制器请求处理器映射器查询Handler

3、处理器映射器返回给前端控制器，返回处理器执行链(HanderExecutionChain)(包含多个处理拦截器和一个Handler实例)

4、前端控制器请求处理器适配器执行Handler。

5、处理器适配器根据适配规则找到特定的处理器(后端controller层URL所绑定的方法)，由处理器来执行Handler

6、处理器执行结束后返回给处理器适配器一个ModelAndView对象，该对象包含数据（Model）和逻辑视图名

7、处理器适配器将ModelAndView对象返回给前端控制器

8、前端控制器请求视图解析器解析视图地址，找到真正的视图

9、视图解析器将真正视图对象返回到前端控制器

10、将数据渲染到视图上

11、将渲染的页面响应给请求用户

 

前端控制器

前端控制器为DispatcherServlet

不需要进行开发

前端控制器是整个用户请求的入口和完成各组件业务转发

所有组件都是直接和前端控制器交互，减少组件间的耦合性

 

处理器映射器

处理器映射为HandlerMapping

不需要进行开发

来存储URL和Handler之间的映射关系，

由前端控制器来判断请求URL是否存在，并返回包含Handler的处理器执行链

 

处理器适配器

处理器适配器为HadlerAdapter

不需要进行开发

按照特定的规则(HandlerAdapter要求的规则)去执行，Handler通过适配器找到真正的执行器，是适配器模式的使用

 

处理器

按照HandlerAdapter的要求开发，Handler是针对用户具体的业务逻辑做响应的处理，Handler涉及到就用户的具体的业务逻辑需要自行开发Handler

 

视图解析器

视图解析器为ViewResolver

不需要进行开发

解析视图，根据逻辑视图名找到真正的视图，视图解析器负责解析View视图即页面的具体的地址位置，jsp、pdf、freeMark等都能完成解析

 

视图

视图为View

需要进行开发

View是一个接口，支持不同的View类型(jsp、pdf、freeMark...),例如jsp是提供了一个jstl

视图是展示给用户的页面，不同的业务展示不同的页面

 

SpringMVC的使用Demo

展示用户列表页面(开发的是处理器（获取用户信息）视图列表页面（JSP）)

1.导入依赖

        <!--web依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

2.配置前端控制器

在web.xml配置文件下引入前端控制器的配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


  <!--前端控制器-->
  <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:spring-mvc.xml</param-value>
    </init-param>
  </servlet>

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

</web-app>

需要在web.xml配置文件中引入前端控制器的实现类：org.springframework.web.servlet.DispatcherServlet，并将SPringMVC的配置添加在web.xml文件中

  <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:spring-mvc.xml</param-value>
    </init-param>
  </servlet>

除此之外也有其他的映射方式

    <servlet-mapping>
        <!--
        第一种：*.action或者*.do，访问形式以.action或.do结果的URL由DispatcherServlet进行解析
        第二种：/ ,所有访问的URL都有DispatcherServlet进行解析，对于静态文件（css，js）的解析是配置不让DispatcherServlet进行解析
        实现RESTFul风格的URL
        第三种：/*,使用这个配置，会转发到jsp的页面，DispatcherServlet任然会解析jsp地址，不能根据jsp找到Handler，会抛出异常
        -->
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

在视图中可以配置访问url的前缀后缀

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

  

3.配置映射器、处理器等

映射器、处理器等需要给定SPringMVC特定的配置文件，这里新建了spring-mvc.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: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 http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">

    <!--SPringMVC需要扫描注解-->
    <context:component-scan base-package="com.tulun.controller"/>
    
    <!--配置处理器映射器、处理器适配器-->
    <mvc:annotation-driven/>
    
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    </bean>
    
</beans>

4.开发视图（UserList.jsp） 

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
        <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
        <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

        <html>
        <head>
        <title>数据展示</title>
        </head>
        <body>
        <table align="center" border="1">
        <thead>
        <tr>
        <td>用户id</td>
        <td>用户名</td>
        </tr>
        </thead>
        <tbody>
        <c:forEach items="${users}" var="user">
            <tr>
            <td>${user.id}</td>
            <td>${user.name}</td>
            </tr>
        </c:forEach>
        </tbody>
        </table>
        </form>

        </body>
        </html>

这里用到了标签，有可能两个jstl报错标红，导致foreach没法用，解决办法是手动在pom.xml中添加这两个依赖。

    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>

5.开发Handler

RequestMapping注解用于实现jsp与url之间的映射。这里的setViewName如果配置了前缀和后缀，就不用把路径写全了，就只需要写一个userlist

@Controller
public class UserController {

    /**
     * 执行器
     * @return
     */
    @RequestMapping("/userlist")
    public ModelAndView userList(){
        
        //返回用户列表
        ArrayList <User> users = new ArrayList <>();

        User u1= new User(1, "tom");
        User u2 = new User(2, "jack");
        User u3 = new User(3, "rose");
        users.add(u1);
        users.add(u2 );
        users.add(u3 );
        
        //封装ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        //封装数据
        modelAndView.addObject("users",users);
        //封装逻辑视图名
        modelAndView.setViewName("/WEB-INF/jsp/userlist.jsp");
        
        return modelAndView;

    }
}

6.将服务部署到Jetty容器

在pom.xml中添加jetty的插件

<!--Jetty福服务器插件-->
          <plugin>
              <groupId>org.mortbay.jetty</groupId>
              <artifactId>maven-jetty-plugin</artifactId>
              <version>6.1.24</version>
              <configuration>
                  <connectors>
                      <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                          <port>8080</port>
                          <maxIdleTime>30000</maxIdleTime>
                      </connector>
                  </connectors>
                  <contextPath>/</contextPath>
              </configuration>
          </plugin>

只后配置目录，在命令行加入jetty:run命令完成即可运行，然后就能运行成功了。

7.将服务部署到Tomcat容器

我还是习惯用Tomcat，可以去官网下载需要的Tomcat版本。IDEA配置Tomcat可以参考https://www.cnblogs.com/weixinyu98/p/9822048.html

如果Tomcat出现乱码的情况，去tomcat的安装目录下的conf的logging.properties，在最后一行添加下列命令，如我的就是E:\apache-tomcat-7.0.108-windows-x64\apache-tomcat-7.0.108\conf就能解决。

 java.util.logging.ConsoleHandler.encoding = GBK

如果啥都配好了还是运行不起来，检查端口占用，要么kell掉tomcat使用的端口，要么就直接给tomcat改个不容易占用的端口号。

运行成功如下：

在浏览器进入到http://localhost:8088/springMVC_war/userlist，显示如下

不知道为啥，我在jetty设置了默认跳转，它死活不跳，tomcat就能跳，至此SpringDemo运行成功。

前端控制器的源码实现流程

前端控制器的实现类org.springframework.web.servlet.DispatcherServlet的执行过程：

所有的请求都会请求到doService方法上

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
       //省略无关代码

		try {
			doDispatch(request, response);
		}
		finally {
			//
		}
	}
    

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
       //mappedHandler是处理器映射器返回的HandlerExecutionChain类型的对象
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
                //第二步：前端控制器调用处理器查找Handler
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (logger.isDebugEnabled()) {
						logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
					}
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
                //调用处理器适配器执行Handler，得到执行结果ModelAndViewView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(request, mv);
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
            //视图渲染，将数据渲染到视图中
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Error err) {
			triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

处理器和适配器的配置

 

基于配置方式来处理处理器和适配器

springMVC中处理器和适配器的使用可以使用配置和注解方式,配置处理器适配器，springMVC提供了org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter类实现，通过源码查看，该适配器支持的Handler必须是Controller接口的实现类，即需要实现COntroller接口，SimpleControllerHandlerAdapter适配器才能支持执行

spring-mvc1.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: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 http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">


    <!--基于配置形式来配置处理器映射器、处理器适配器和视图解析器-->

    <!--处理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>



    <!--配置Handler实例，将实例交给容器管理-->
    <bean name="/userlist1" class="com.tulun.controller.UserController1"/>


    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>


    <!--视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--jsp页面前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>

        <!--jsp后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

handler开发 

package com.tulun.controller;

import com.tulun.controller.bean.User;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;

/**
 * Description :
 * Created by Resumebb
 * Date :2021/4/18
 */
public class UserController1 implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ArrayList<User> users = new ArrayList<>();
        User u1 = new User(1,"张三");
        User u2 = new User(2,"李四");
        User u3 = new User(3,"王五");
        users.add(u1);
        users.add(u2);
        users.add(u3);

        //返回ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("users",users);
        modelAndView.setViewName("userlist");
        return modelAndView;

    }
}

 基于该配置形式是，一个Controller实现类只能针对特定的一个URL做处理，即一个Handler只能一个类来处理，多个Handler（即针对不同的URL）是需要不同的Controller实现类来处理，且将实现类都要交给容器管理

注意：在基于非注解的处理器中使用的两个框架类：

  • org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
  • org.springframework.web.servlet.handler.SimpleUrlHandlerMapping

为了区别userlist.jsp，将handler映射到userlist1.jsp上，jsp内容无异。

部署结果

网页显示： 

基于注解形式处理适配器处理器

spring-mvc.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: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 http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">



    <!--&lt;!&ndash;配置处理器映射器、处理器适配器&ndash;&gt;-->
    <!--<mvc:annotation-driven/>-->

    <!--处理器映射器在spring3.1之前使用-->
    <!--org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping。-->
    <!--处理器映射器在spring3.1之后使用
    org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping。-->
    <!--处理器适配器在spring3.1之前使用-->
    <!--org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter。-->
    <!--处理器适配器在spring3.1之后使用
    org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter。-->

    <!--处理器映射器-->
    <!--<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>-->

    <!--处理器适配器-->
    <!--<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>-->


    <!--SPringMVC需要扫描注解-->
    <context:component-scan base-package="com.tulun.controller"/>

    <!--配置处理器映射器、处理器适配器-->
    <mvc:annotation-driven/>

    <!--视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--jsp页面前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>

        <!--jsp后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

handler开发

基于配置方式的url只能对应一个handler，但是基于注解的可以对应多个url

package com.tulun.controller;

import com.tulun.controller.bean.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import java.util.ArrayList;

/**
 * Description :
 * Created by Resumebb
 * Date :2021/4/17
 */
@Controller
public class UserController {


    @RequestMapping("/test")
    public @ResponseBody
    String test(){
        return "hello Tulun";
    }

    /**
     * 执行器
     * @return
     */
    @RequestMapping("/userlist")
    public ModelAndView userList(){

        //返回用户列表
        ArrayList <User> users = new ArrayList <>();

        User tulun = new User(1, "tom");
        User java = new User(2, "jack");
        User user = new User(3, "rose");
        users.add(tulun);
        users.add(java);
        users.add(user);

        //封装ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        //封装数据
        modelAndView.addObject("users",users);
        //封装逻辑视图名 /WEB-INF/jsp/userlist.jsp
        modelAndView.setViewName("userlist");

        return modelAndView;

    }

    @RequestMapping("/userlist1")
    public ModelAndView test1(){

        //返回用户列表
        ArrayList <User> users = new ArrayList <>();

        User tulun = new User(1, "张三");
        User java = new User(2, "李四");
        User user = new User(3, "王五");
        users.add(tulun);
        users.add(java);
        users.add(user);

        //封装ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        //封装数据
        modelAndView.addObject("users",users);
        //封装逻辑视图名 /WEB-INF/jsp/userlist.jsp
        modelAndView.setViewName("userlist1");

        return modelAndView;

    }
}

部署结果 

http://localhost:8088/springMVC_war/test：

http://localhost:8088/springMVC_war/userlist：

http://localhost:8088/springMVC_war/userlist1：

 

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

SpringMVC

设计模式

SpringMVC设计模式 的相关文章

随机推荐

  • HashMap的使用与底层结构剖析

    目录 一 基础概念 二 先使用再了解 三 底层结构 1 HashMap结构 xff08 JDK1 8以前 xff09 2 HashMap结构 xff08 JDK1 8以后 xff09 四 HashMap实现 1 成员变量 2 put实现 3

  • 线程基础与使用测试

    目录 一 进程和线程 二 线程的创建 1 继承Thread类 xff0c 重写run 方法 2 实现Runnable接口 xff0c 重写run方法 3 匿名线程 xff0c 匿名内部类 4 实现Callable接口 xff0c 重写cal

  • 线程生命周期及常用方法的使用

    一 守护线程 守护线程是什么 xff1f 守护线程是一类比较特殊的线程 xff0c 一般用于处理后台的工作 xff0c 比如JDK的垃圾回收线程 守护线程的作用 xff1f JVM xff08 Java Virtual Machine xf

  • git合并被fork的仓库的远程分支

    如果你 fork 了一个仓库并在自己的 forked 仓库中进行了更改 xff0c 而原始仓库也有一些更新 xff0c 此时想将原始仓库的更新合并到你的 forked 仓库 xff0c 可以按照以下步骤 xff1a 1 将原始仓库添加为远程

  • Linux-基础知识及常见操作命令汇总

    目录 1 终端操作 2 命令手册 3 关机重启 4 runlevel 5 目录结构 6 文件属性 7 Linux文件属主和属组 8 目录常用命令 9 VIM命令 10 进程管理命令 1 进程状态 2 ps命令 3 pstree命令 jobs

  • 关键字synchronized与volatile详解

    在多线程并发编程中synchronized和volatile都扮演着重要的角色 xff0c synchronized一直是元老级角色 xff0c 很多人都会称呼它为重量级锁 但是 xff0c 随着Java SE 1 6对synchroniz

  • 迁移学习与Transformer架构

    迁移学习 迁移学习干什么的 xff1f 迁移学习是通过从已学习的相关任务中转移知识来改进学习的新任务 Eg xff1a 学习识别苹果可能有助于识别梨 xff0c 学习骑自行车可能有助于学习骑摩托车 xff0c 学习打羽毛球可能有助于学习打网

  • 生产者消费者模型分析与实现

    生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题 生产者和消费者彼此之间不直接通讯 xff0c 而通过阻塞队列来进行通讯 xff0c 所以生产者生产完数据之后不用等待消费者处理 xff0c 直接扔给阻塞队列 xff0c 消费

  • ConcurrentHashMap优点与源码剖析

    哈希表是中非常高效 xff0c 复杂度为O 1 的数据结构 xff0c 在Java开发中 xff0c 我们最常见到最频繁使用的就是HashMap和HashTable xff0c 但是在线程竞争激烈的并发场景中使用都不够合理 HashMap

  • IO-字节流

    文件 amp File类的使用 1 文件的概念 文件可以分为文本文件 二进制文件 2 IO流的概念 流是有顺序 有起点和终点的集合 xff0c 是对数据传输的总称 流的本质就是用来对数据进行操作 IO是我们实现的目的 xff0c 实现这个目

  • STM32F407的TCP编程出现客户端无法连接上服务器，DHCP获取IP失败，服务器重启客户端无法自动重连问题解决方案

    单写一篇文章记录这些问题 xff0c 因为有的问题实在是困扰了我太久太久了 xff0c 终于解决了 xff01 xff01 xff01 1 STM32F407的TCP编程 xff0c TCP SERVER测试完全正常 xff0c TCP C

  • SQL练习汇总（查询“01“课程比“02“课程成绩高的学生的信息及课程分）

    1 学生表 Student SID Sname Sage Ssex SID 学生编号 Sname 学生姓名 Sage 年龄 Ssex 学生性别 编号 姓名 年龄 性别 1 赵雷 20 男 2 钱电 20 男 3 孙风 21 男 4 吴兰 1

  • JDBC编程，SQL注入与连接池

    JDBC概念 JDBC Java Data Base Conection 是java中提供的一套标准的应用编程接口 xff0c 用来连接Java编程语言和数据库 JDBC常用组件 xff1a DriverManger xff1a 数据库驱动

  • Pytorch搭建基于SRCNN图像超分辨率重建模型及论文总结

    SRCNN xff08 Super Resolution Convolutional Neural Network xff09 论文出处 xff1a Learning a Deep Convolutional Network for Ima

  • 技术领域的面试总结

    在当今互联网中 xff0c 虽然互联网行业从业者众多 xff0c 不断崛起的互联网公司也会很多 xff0c 仍然是很多同学想要进入的企业 那么本篇文章将会为大家很直白的讲解面试流程以及侧重点 仔细阅读本篇文章 xff0c 绝对会有所收获 x

  • Mybatis基于XML与基于注解实现CRUD

    数据库 实体类Student package com pojo Description Created by Resumebb Date 2021 3 26 public class Student 和数据库中的STudent表对应 pri

  • Spring-IOC容器进行对象管理

    目录 IOC概念 IOC思想 Spring管理对象 集成依赖 spring的配置文件 xff08 Applicationcontext xml xff09 创建实体类User Spring对Bean的实例化方式 基于配置形式 1 通过无参构

  • Spring-AOP原理及实现

    Spring AOP AOP Aspect Oriented Programing 面向切面编程 xff1a 扩展功能不通过修改源代码实现 AOP采用横向抽取机制 xff0c 取代传统纵向继承体系实现响应的功能 xff08 性能监控 事务

  • Spring&Mybatis整合及Spring中JDBCTemplate的使用

    Spring和Mybatis整合 在mybatis中 xff0c 操作数据库需要获取到SQLSession对象 xff0c 而该对象的实例过程在mybatis是通过SQLSessionFactoryBuilder读取全局配置文件来实例化一个

  • SpringMVC设计模式

    什么是MVC MVC是模型 Model 视图 View 控制器 Controller 的简写 xff0c 是一种软件设计规范 是将业务逻辑 数据 显示分离的方法来组织代码 MVC主要作用是降低了视图与业务逻辑间的双向偶合 MVC不是一种设计

热门标签