JavaWeb学习之——Spring篇之HandlerMapping

最新推荐文章于 2024-05-16 13:59:28 发布
最新推荐文章于 2024-05-16 13:59:28 发布
阅读量690 收藏
点赞数
文章标签： 测试 java
原文链接：https://my.oschina.net/u/3039671/blog/825068
版权

1.HandlerMapping

HandlerMapping接口只有一个方法

HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

就是根据Reuqest返回HandlerExecutionChain，看名字就知道是一个处理链，包含多个Interceptor和一个Handler。

203621_vbwF_3039671.png

2.AbstractHandlerMapping

AbstractHandlerMapping是HanlderMapping的默认实现类。是一个模板方法（Spring 底层大代码大量使用模板方法）。

2.1 初始化interceptor

@Override
protected void initApplicationContext() throws BeansException {
   extendInterceptors(this.interceptors);
   detectMappedInterceptors(this.adaptedInterceptors);
   initInterceptors();
}

deleteMappedIntercptors方法的左右就是把ApplicationContext中所有类型为MappedInterceptor的bean加入到adaptedIntercptors这个成员变量中

protected void detectMappedInterceptors(List<HandlerInterceptor> mappedInterceptors) {
   mappedInterceptors.addAll(
         BeanFactoryUtils.beansOfTypeIncludingAncestors(
               getApplicationContext(), MappedInterceptor.class, true, false).values());
}

initInterceptors()函数的作用就是把成员变量interceptors中的interceptor加入到adaptedInterceptors成员变量中去，如果是WebRequestInterceptor则转换为对应的adapter类，代码如下

protected void initInterceptors() {
   if (!this.interceptors.isEmpty()) {
      for (int i = 0; i < this.interceptors.size(); i++) {
         Object interceptor = this.interceptors.get(i);
         if (interceptor == null) {
            throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
         }
         this.adaptedInterceptors.add(adaptInterceptor(interceptor));
      }
   }
}
protected HandlerInterceptor adaptInterceptor(Object interceptor) {
   if (interceptor instanceof HandlerInterceptor) {
      return (HandlerInterceptor) interceptor;
   }
   else if (interceptor instanceof WebRequestInterceptor) {
      return new WebRequestHandlerInterceptorAdapter((WebRequestInterceptor) interceptor);
   }
   else {
      throw new IllegalArgumentException("Interceptor type not supported: " + interceptor.getClass().getName());
   }
}

2.2 实现Handler接口

@Override
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
   Object handler = getHandlerInternal(request);
   if (handler == null) {
      handler = getDefaultHandler();
   }
   if (handler == null) {
      return null;
   }
   // Bean name or resolved handler?
   if (handler instanceof String) {
      String handlerName = (String) handler;
      handler = getApplicationContext().getBean(handlerName);
   }

   HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
   if (CorsUtils.isCorsRequest(request)) {
      CorsConfiguration globalConfig = this.corsConfigSource.getCorsConfiguration(request);
      CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
      CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
      executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
   }
   return executionChain;
}

主要做了2件事：

  • 1.获取request对应的Handler,获取handler是通过getHandlerInternal方法，这个由子类去实现 
  • 2.找出对应的Interceptors返回HandlerExecutionChain,从根据request找出合适的Interceptors加入其中（例如MappedInterceptor是根据url地址来判断是否加入）。

AbstractHandleMapping是一个模板方法，子类需要实现getHandlerInternal。下面介绍2个主要实现类AbstractUrlHandleMapping和AbstractHandleMethodMapping。

3. AbstractUrlHandleMapping

3.1 getHandlerInternal

从名字可以猜到，AbstractUrlHandleMapping是通过url来匹配对应的Handler。AbstractUrlHandleMapping依然是一个抽象类。getHandlerInternal代码：

/**
 * 根据request的url查询对应的handler
 */
@Override
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
   //查找url地址，有可能是servlet的url，也有可能是Spring Mvc定义的url
   String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
   //通过url查找对应的Handler
   Object handler = lookupHandler(lookupPath, request);
   //如果找不到对应的handler
   if (handler == null) {
      // 特殊情况，如果查询地址为"/",则判断是否用rootHandler，如果没有就设置为defaultHandler
      Object rawHandler = null;
      if ("/".equals(lookupPath)) {
         rawHandler = getRootHandler();
      }
      if (rawHandler == null) {
         rawHandler = getDefaultHandler();
      }
      if (rawHandler != null) {
         // 如果是字符串，则从ApplicationConetxt中获取对应的bean
         if (rawHandler instanceof String) {
            String handlerName = (String) rawHandler;
            rawHandler = getApplicationContext().getBean(handlerName);
         }
         //模板方法，验证Handler
         validateHandler(rawHandler, request);
         //返回HandlerExecutionChain类型，会注册2个interceptor
         //PathExposingHandlerInterceptor和UriTemplateVariablesHandlerInterceptor
         handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
      }
   }
   if (handler != null && logger.isDebugEnabled()) {
      logger.debug("Mapping [" + lookupPath + "] to " + handler);
   }
   else if (handler == null && logger.isTraceEnabled()) {
      logger.trace("No handler mapping found for [" + lookupPath + "]");
   }
   return handler;
}

主要做了一下几件事：

  1. 根据request生成查询handler的URL
  2. 根据url获取对应的handler
  3. 如果handler没有在map中查到，则使用默认的handler。

3.2 lookupHandler

方法目的就是根据url 查找对应的Handler，但是在url匹配的时候往往会有"/test/*"或者Path变量“/test/{id}”这样的情况，这样就无法通过url地址直接从map中获取对应的handler。

protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
   // 能否直接找到
   Object handler = this.handlerMap.get(urlPath);
   if (handler != null) {
      // 如果是字符串从ApplicationContext中直接获取
      if (handler instanceof String) {
         String handlerName = (String) handler;
         handler = getApplicationContext().getBean(handlerName);
      }
      // 模板方法，验证handler
      validateHandler(handler, request);
      //返回HandlerExecutionChain类型，会注册2个interceptor
      //PathExposingHandlerInterceptor和UriTemplateVariablesHandlerInterceptor
      return buildPathExposingHandler(handler, urlPath, urlPath, null);
   }
   // 模板匹配
   List<String> matchingPatterns = new ArrayList<String>();
   for (String registeredPattern : this.handlerMap.keySet()) {
      if (getPathMatcher().match(registeredPattern, urlPath)) {
         matchingPatterns.add(registeredPattern);
      }
      else if (useTrailingSlashMatch()) {
         if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
            matchingPatterns.add(registeredPattern +"/");
         }
      }
   }
   //根据order找出优先级坐高的
   String bestPatternMatch = null;
   Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
   if (!matchingPatterns.isEmpty()) {
      Collections.sort(matchingPatterns, patternComparator);
      if (logger.isDebugEnabled()) {
         logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);
      }
      bestPatternMatch = matchingPatterns.get(0);
   }
   if (bestPatternMatch != null) {
      handler = this.handlerMap.get(bestPatternMatch);
      if (handler == null) {
         Assert.isTrue(bestPatternMatch.endsWith("/"));
         handler = this.handlerMap.get(bestPatternMatch.substring(0, bestPatternMatch.length() - 1));
      }
      
      if (handler instanceof String) {
         String handlerName = (String) handler;
         handler = getApplicationContext().getBean(handlerName);
      }
      validateHandler(handler, request);
      String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPatternMatch, urlPath);

      // 这里是处理当有多个url和最优的path是同一优先级的，那么从里面获取地址变量，加入到uriTemplateVariables中
      Map<String, String> uriTemplateVariables = new LinkedHashMap<String, String>();
      for (String matchingPattern : matchingPatterns) {
         if (patternComparator.compare(bestPatternMatch, matchingPattern) == 0) {
            Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
            Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
            uriTemplateVariables.putAll(decodedVars);
         }
      }
      return buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
   }
   //找不到对应的handler
   return null;
}

这个函数主要完成了几下几件事

  1. url能直接从map中获取的则直接获取
  2. 否则通过路径pattern去匹配url
  3. 从所有匹配到handler查找出优先级最高的
  4. 如果有多个同最优先级的，则查看里面是否有pathVariable
  5. 找到任意的Handler则加入2个特殊的interceptor

3.3 buildPathExposingHandler 

上面所有的能成功找到对应的handler后，都会调用这个方法。这儿方法就是在handler的基础上，加入2个interceptor，返回一个HandlerExecutionChain

protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
      String pathWithinMapping, Map<String, String> uriTemplateVariables) {

   HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
   chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
   if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
      chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
   }
   return chain;
}

这2个interceptor的作用就是当前匹配的url、匹配条件和url模板参数设置到request的attribute里面

3.4 Map初始化

上面一直说的通过url从map中获取对应的Handler，这个map是成员变量

private final Map<String, Object> handlerMap = new LinkedHashMap<String, Object>();

这个map的初始化是在registerHandler方法，这个方法比较功能比较简单，参数分别是url和handler，然后把url和handler放入map中，再做一些重复检查和特殊handler（roothandler）的设置。url和handler从哪里来，则又是子类提供处理具体的逻辑来调用这个方法。

到这里，关于怎么通过url来获取handler已经解决了，下面就是url和handler是怎么注册到handlermap中的，其中大部分子类都被@Deprecated标记，

140403_yCyj_3039671.png

3.5 SimpleUrlHandlerMapping

这个类非常简单，就是给定参数map，注册到handlermap中

protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
   if (urlMap.isEmpty()) {
      logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");
   }
   else {
      for (Map.Entry<String, Object> entry : urlMap.entrySet()) {
         String url = entry.getKey();
         Object handler = entry.getValue();
         // Prepend with slash if not already present.
         if (!url.startsWith("/")) {
            url = "/" + url;
         }
         // Remove whitespace from handler bean name.
         if (handler instanceof String) {
            handler = ((String) handler).trim();
         }
         registerHandler(url, handler);
      }
   }
}

4. AbstractHandlerMethodMapping

现在来看看AbstractHandlerMapping的另外一个继承 AbstractHandlerMethodMapping

140738_FOFj_3039671.png

AbstractHandlerMethodMapping从名字就可以看出，是把一个方法作为一个handler。并且继承体系也十分清晰。分析的顺序和AbstractUrlHandleMapping类似，首先还是先分析一下getHandlerInternal这个方法

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
   String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
   if (logger.isDebugEnabled()) {
      logger.debug("Looking up handler method for path " + lookupPath);
   }
   this.mappingRegistry.acquireReadLock();
   try {
      HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
      if (logger.isDebugEnabled()) {
         if (handlerMethod != null) {
            logger.debug("Returning handler method [" + handlerMethod + "]");
         }
         else {
            logger.debug("Did not find handler method for [" + lookupPath + "]");
         }
      }
      return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
   }
   finally {
      this.mappingRegistry.releaseReadLock();
   }
}

看起来和AbstractUrlHandleMapping类似，只不过AbstractUrlHandleMapping中的handler是一个bean，而AbstractHandlerMethodMapping的handler是一个Method

初始化方法initHandlerMethods：

protected void initHandlerMethods() {
   //获取所有beanName
   String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
         BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
         getApplicationContext().getBeanNamesForType(Object.class));

   for (String beanName : beanNames) {
      //beanName是以scopedTarget.开头的，则不用户Handler Method
      if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
         Class<?> beanType = null;
         try {
            beanType = getApplicationContext().getType(beanName);
         }
         catch (Throwable ex) {
            ...
         }
         // isHandler模板方法，由子类去判断改bean是否注册
         if (beanType != null && isHandler(beanType)) {
            //注册到HandlerMethod
            detectHandlerMethods(beanName);
         }
      }
   }
   //初始化HandlerMethod
   handlerMethodsInitialized(getHandlerMethods());
}

detectHandlerMethods，就是注册handlerMethod。具体说明看注解

protected void detectHandlerMethods(final Object handler) {
   Class<?> handlerType = (handler instanceof String ?
         getApplicationContext().getType((String) handler) : handler.getClass());
   final Class<?> userType = ClassUtils.getUserClass(handlerType);
  
   //查找该handler中的method及其对应的条件（参照@RequestMapping中的参数）
   Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
         new MethodIntrospector.MetadataLookup<T>() {
            @Override
            public T inspect(Method method) {
               return getMappingForMethod(method, userType);
            }
         });
   for (Map.Entry<Method, T> entry : methods.entrySet()) {
      Method invocableMethod = AopUtils.selectInvocableMethod(entry.getKey(), userType);
      T mapping = entry.getValue();
      registerHandlerMethod(handler, invocableMethod, mapping);
   }
}
  1.  isHandler 是一个模板方法，由子类去判断改bean是否是一个handler。
  2. getMappingForMethod也是一个模板方法，判断一个类中Method方法的相关条件信息
  3. detectHandlerMethods是在传入的beanName对应的bean中查找handlerMethod，然后注册
  4. handlerMethodsInitialized 是一个预留方法，里面没有做任何事，如果我们自定义一个HandlerMapping有需要的话可以重写

4.1 RequestMappingHandlerMapping

RequestMappingHandlerMapping继承AbstractHandlerMethodMapping，首先看两个模板方法

isHandler，就是判断是否有Controller或者RequestMapping注解。

@Override
protected boolean isHandler(Class<?> beanType) {
   return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
         AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}

getMappingForMethod这个方法就是根据传入的函数，返回一个RequestMappingInfo （也就是@RequestMapping中的参数信息）

@Override
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
   RequestMappingInfo info = createRequestMappingInfo(method);
   if (info != null) {
      RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
      if (typeInfo != null) {
         info = typeInfo.combine(info);
      }
   }
   return info;
}

这样，AbstractHandlerMethodMapping的就能通过一个url可以找出对应MethodHandler，

转载于:https://my.oschina.net/u/3039671/blog/825068

chuandie7960
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HandlerMapping
1
11-23 436
默认情况下，Spring MVC会加载在当前系统中所有实现了HandlerMapping接口的bean，再进行按优先级排序。如果只期望Spring MVC只加载指定的HandlerMapping，可以修改web.xml中的DispatcherServlet的初始化参数，将detectAllHandlerMappings的值设置为false。这样，Spring MVC就只会查找名为“handlerMapping”的bean，并作为当前系统的唯一的HandlerMapping。所以在DispatcherServ
RequestMappingHandlerMapping的工作原理
WannaRunning的博客
07-23 1151
使用SpringMVC开发的人都知道最常用的定义接口的方式就是借助于@Controller和@RequestMapping等注解实现。而RequestMappingHandlerMapping类就是用于扫描注解和生成URL映射，处理请求时的URL映射匹配等关键功能的。 请求时如何到达对应的方法的 在DispatchServlet中，doDispatch方法会历各种HandlerMapping。当遍历到RequestMappingHandlerMapping时，RequestMappingHandlerM
Spring MVC核心组件之HandlerMapping详解
最新发布
老码农的博客
05-16 1137
当一个web请求到来时，DispatcherServlet负责接收请求并响应结果。DispatcherServlet首先需要找到当前请求对应的handler（处理器）来处理请求，流程如下图所示。DispatcherServlet中有一个成员变量叫做handlerMappings，是一个HandlerMapping的集合，当请求到来时，DispatcherServlet遍历handlerMappings中的每一个HandlerMapping以获取对应的handler。
拦截器HandlerInterceptorAdapter使用方法
热门推荐
苍白的咏叹调的博客
12-06 3万+
一、Interceptor定义： 拦截器是在面向切面编程中应用的，就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法。是基于JAVA的反射机制 1.拦截器（Interceptor）执行顺序： 1. 请求到达 DispatcherServlet 2. DispatcherServlet 发送至 Interceptor ，执行 preHandle 3. 请求达到 Controller 4. 请求结束后，postHandle 执行 2.拦截器（Interceptor）和过滤器（.
SpringBoot、SpringMVC中的HandlerInterceptorAdapter 简单拦截HTTP请求功能
风兮雨露的博客
07-15 3500
1、SpringWebMVC的处理器拦截器，类似于Servlet开发中的过滤器Filter，可以用于处理器进行预处理和后处理。 在SpringBoot中我们可以使用HandlerInterceptorAdapter这个适配器来实现自己的拦截器。这样就可以拦截所有的请求并做相应的处理。 在HandlerInterceptorAdapter中主要提供了以下的方法： preHandle：在...
springboot修改ReqeustMappingHandlerMapping
qq_36022463的博客
07-28 705
将http请求映射到处理的方法上,负责解析处理器方法上的注解…,将请求路径，请求方法，请求参数等信息和 处理器方法建立映射。可以定义自己的 ，处理器映射器，等，，，
基于Java的JavaWeb学习之Servlet设计源码
04-14
本项目是基于Java的JavaWeb学习之Servlet设计源码，共有40个文件，包括15个XML文件、12个Java文件等。系统旨在为学习JavaWeb的学生提供一个Servlet的实践平台，涵盖了Servlet的基本概念和应用场景。项目的设计注重...
JavaWeb综合案例——品牌后台管理系统
08-12
最新版JavaWeb综合案例——品牌后台管理系统 来源：改编自黑马程序员最新JavaWeb课程案例 所用技术及工具：Mybatis+Maven+Filter+Ajax+JSON+JavaScript+HTML+CSS+Element+VUE
javaWeb训练专用——软件项目信息管理
04-14
JavaWeb训练专用——软件项目信息管理系统是一个针对初学者和进阶者设计的实践项目，旨在提升开发者在JavaWeb领域的技能。这个项目的难度等级为3星，比基础的2星项目更具挑战性，涵盖了更多核心技术和实际应用。 在...
JavaWeb开发教程——入门与提高篇
05-07
本教程“JavaWeb开发教程——入门与提高篇”旨在帮助学习者从零开始，逐步掌握JavaWeb开发的基本技能，并提升到高级水平。 首先，让我们了解JavaWeb开发的基础。JavaWeb开发主要涉及使用Java语言进行服务器端编程，...
JavaWeb Spring注解Annotation深入学习
09-01
主要为大家详细介绍了JavaWeb Spring注解Annotation,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
handlerMapping目前三种常用的实现
qq_35939148的博客
02-17 1266
转载来源：https://www.jianshu.com/p/e4f1c9326223 我们在进行SSM框架开发过程中涉及到映射处理配置时，会使用HandlerMapping接口的各种实现类(如下图所示)，本文主要介绍默认加载的三个handlerMapping，今后工作学习中遇到更适合某种业务场景的HandlerMapping会慢慢补充。 正文开始 说道目前最长用的handlerMapp...
Spring拦截器
qq_43372409的博客
12-23 931
一、拦截器（1） 　　一）、HandlerInterceptor（拦截器） 　　　☆☆☆定义实现类 　　　　方式一：类实现Spring的HandlerInterceptor接口 　　　　方式二：类继承实现了HandlerInterceptor接口的类，如实现了HandlerInterceptor接口的抽象类 → 　　　HandlerInterceptorAdapter 　　　☆☆☆方式介...
面试官：给我说一下 Spring MVC 拦截器的原理？
勇往直前的专栏
10-26 3141
前言 SpringMVC是目前主流的Web MVC框架之一。 拦截器是每个Web框架必备的功能，也是个老生常谈的主题了。 本文将分析SpringMVC的拦截器功能是如何设计的，让读者了解该功能设计的原理。 重要接口及类介绍 1. HandlerExecutionChain类 由HandlerMethod和Interceptor集合组成的类，会被HandlerMapping接口的getHandler方法获取。 2. HandlerInterceptor接口 SpringMVC拦截器基础
SpringMVC中的拦截器Interceptor
qq_42640067的博客
03-15 1420
拦截器的使用1、拦截器的使用时机2、拦截器的原理3、拦截器的使用4、测试拦截器Intercaptor和过滤器Filter 1、拦截器的使用时机 SpringMVC中提供了一个拦截器Interceptor，其功能类似于Servlet中的过滤器Filter，但是拦截器只能拦截请求，并不能拦截响应。常用拦截器进行用户的权限验证，以及判断用户是否登录系统，未登录的进行拦截等。当你需要对用户的某些请求进行拦截时，比如非法请求，那么就可以使用拦截器来实现。 2、拦截器的原理 SpringMVC中提供了拦截器Handle
Spring Web : HandlerMethodReturnValueHandler 实现类清单
Details Inside Spring
08-19 301
jar包org.springframework:spring-web:5.1.5.RELEASE java包org.springframework.web.method.annotation MapMethodProcessor – Map类型返回值 ModelAttributeMethodProcessor – 方法使用注解@ModelAttribute时的返回值，或者为非简单类型的返回值...
springMVC HandlerExecutionChain处理器执行链Handler和Interceptor详情
weixin_41883396的博客
01-18 3448
简介springMVC的工作流程： 在web.xml中部署DispaterServlet，并配置springmvc.xml等文件; 将映射文件请求到处理器HandlerMapping; HandlerMapping会把请求映射为HandlerExecutionChain类型的handler对象; 将handler对象作为参数传递给HandlerAdapter的实例化对象，调用其handler方法会...
springboot源码系列-HandlerMapping（2）
xiaomujiang_dafangzi的博客
10-24 156
读完第一篇文章 总觉得这一块哪还有缺失。所以还是继续把上一篇文章缺失部分补全。我们接着上一遍文章讲的SimpleUrlHandlerMapping 接下来讲一下他的孪生兄弟BeanNameUrlHandlerMapping和他俩的堂兄弟RequestMappingHandlerMapping（我们经常使用的一个HandlerMapping） 1，BeanNameUrlHandler...
JavaWeb综合实验——CRUD的实验目的
06-12
JavaWeb综合实验——CRUD的实验目的主要有以下几个方面： 1. 培养学生的Web开发能力：通过实验，让学生掌握Web开发的基本知识和技能，如HTML、CSS、JavaScript等。 2. 培养学生的Servlet和JSP编程能力：通过实验，让学生掌握Servlet和JSP的基本用法和编程技能，如请求和响应、会话管理、数据传递等。 3. 培养学生的数据库操作能力：通过实验，让学生掌握数据库的基本概念和操作技能，如创建表、增删改查等。 4. 培养学生的实际应用能力：通过实验，让学生学会将所学的知识应用于实际项目中，提高学生的实际应用能力。 5. 培养学生的团队协作精神：通过实验，让学生学会与同学一起协作完成项目，培养学生的团队协作精神。 6. 增强学生的代码编写能力：通过实验，让学生学会编写高质量、可维护性强的代码，提高学生的代码编写能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值