Springmvc_day01

最新推荐文章于 2022-07-17 14:43:29 发布
最新推荐文章于 2022-07-17 14:43:29 发布
阅读量154 收藏
点赞数
分类专栏： springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a17712875660/article/details/106254375
版权

文章目录

Spring_day1

MVC模型

  1. MVC全名是Model View Controller 模型视图控制器，每个部分各司其职。
  2. Model：数据模型，JavaBean的类，用来进行数据封装。
  3. View：指JSP、HTML用来展示数据给用户
  4. Controller：用来接收用户的请求，整个流程的控制器。用来进行数据校验等

SpringMVC 和 Struts2 的优略分析

  • 共同点：

    • 它们都是表现层框架，都是基于 MVC 模型编写的。
    • 它们的底层都离不开原始 ServletAPI。
    • 它们处理请求的机制都是一个核心控制器。

  • 区别：

    • Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter

    • Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。

    • Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便
      (JSR303 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注解加在我们 JavaBean 的属性上面，就可以在需要校验的时候进行校验了。)

    • Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提升，尤其是 struts2 的表单标签，远没有 html 执行效率高。

SpringMVC的入门案例

  1. 创建WEB工程，引入开发的jar包

    <!-- 版本锁定 -->
<properties>
	<spring.version>5.0.2.RELEASE</spring.version>
</properties>

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>

  2. 配置核心的控制器（配置DispatcherServlet）

    1. 在web.xml配置文件中核心控制器DispatcherServlet
    <!-- SpringMVC的核心控制器 -->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
	<!-- 配置servlet启动时加载对象 -->
    <load-on-startup>1</load-on-startup>
    
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  3. 编写springmvc.xml的配置文件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="cn.myp666"></context:component-scan>
	<!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!--后缀-->
        <property name="suffix" value=".jsp"></property>
    </bean>
	<!-- 配置spring开启注解mvc的支持-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

  4. 编写index.jsp和HelloController控制器类

    • index.jsp

      <body>
<h3>入门案例</h3>
<a href="hello">入门案例</a>
</body>

    • HelloController

      /**
* 控制器
*
*/
@Controller
public class HelloController {
	/**
	* 接收请求
	* @return
	*/
    @RequestMapping(path = "/hello")
    public String helloController(){
        System.out.println("你好");
        return "success";
    }
}

  5. 在WEB-INF目录下创建pages文件夹，编写success.jsp的成功页面

入门案例的执行过程分析

  1. 入门案例的执行流程

    1. 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，就会加载springmvc.xml配置文件
    2. 开启了注解扫描，那么HelloController对象就会被创建
    3. 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解找到执行的具体方法
    4. 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件
    5. Tomcat服务器渲染页面，做出响应

SpringMVC 的请求响应流程

入门案例中涉及的组件

  1. DispatcherServlet：前端控制器

    作用接收请求，响应结果，相当于转发器，中央处理器。
    有了DispatcherServlet减少了其它组件之间的耦合度。

  2. HandlerMapping：处理器映射器
    根据请求的url查找Handler

  3. Handler：处理器
    按照特定规则（HandlerAdapter要求的规则）去执行Handler

  4. HandlAdapter：处理器适配器
    注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler

  5. View Resolver：视图解析器
    作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）

  6. View：视图
    View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）

  7. mvc:annotation-driven说明
    在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。
    使 用mvc:annotation-driven自动加载 RequestMappingHandlerMapping （处理映射器） 和RequestMappingHandlerAdapter （ 处 理 适 配 器 ） ， 可 用 在 SpringMVC.xml 配 置 文 件 中 使 用
    **mvc:annotation-driven替代注解处理器和适配器的配置。

Springmvc架构原理解析
  1. 第一步：发起请求到前端控制器(DispatcherServlet)
  2. 第二步：前端控制器请求HandlerMapping查找 Handler
    可以根据xml配置、注解进行查找
  3. 第三步：处理器映射器HandlerMapping向前端控制器返回Handler
  4. 第四步：前端控制器调用处理器适配器去执行Handler
  5. 第五步：处理器适配器去执行Handler
  6. 第六步：Handler执行完成给适配器返回ModelAndView
  7. 第七步：处理器适配器向前端控制器返回ModelAndView
    ModelAndView是springmvc框架的一个底层对象，包括 Model和view
  8. 第八步：前端控制器请求视图解析器去进行视图解析
    根据逻辑视图名解析成真正的视图(jsp)
  9. 第九步：视图解析器向前端控制器返回View
  10. 第十步：前端控制器进行视图渲染
    视图渲染将模型数据(在ModelAndView对象中)填充到request域
  11. 第十一步：前端控制器向用户响应结果

RequestMapping 注解

  • 使用说明

  • 源码：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
}
  • 作用：
    • 用于建立请求 URL 和处理请求方法之间的对应关系。
  • 出现位置：
    • 类上：
      请求 URL 的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以/开头。
      它出现的目的是为了使我们的 URL 可以按照模块化管理:
    • 方法上：
      请求 URL 的第二级访问目录。
  • 属性：
    • value：用于指定请求的 URL。它和 path 属性的作用是一样的。
    • method：用于指定请求的方式。
    • params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的 key 和 value 必须和配置的一模一样。
      • 例如：
        params = {“accountName”}，表示请求参数必须有 accountName
        params = {“moeny!100”}，表示请求参数中 money 不能是 100。
    • headers：用于指定限制请求消息头的条件。

请求参数的绑定

绑定的机制

表单中请求参数都是基于 key=value 的。
SpringMVC 绑定请求参数的过程是通过把表单提交请求参数，作为控制器中方法参数进行绑定的。
例如：

<a href="account/findAccount?accountId=10">查询账户</a>

  • 中请求参数是： accountId=10

    /**
* 查询账户
* @return
*/
@RequestMapping("/findAccount")
public String findAccount(Integer accountId) {
	System.out.println("查询了账户。。。。"+accountId);
	return "success";
}
支持的数据类型：

  • 基本类型参数：
    包括基本类型和 String 类型

  • POJO 类型参数：
    包括实体类，以及关联的实体类

  • 数组和集合类型参数：
    包括 List 结构和 Map 结构的集合（包括数组）

    SpringMVC 绑定请求参数是自动实现的，但是要想使用，必须遵循使用要求。

如果是基本类型或者 String 类型：

  • jsp 代码：

    <!-- 基本类型示例 -->
<a href="account/findAccount?accountId=10&accountName=zhangsan">查询账户</a>

  • 控制器代码：

    /**
* 查询账户
* @return
*/
@RequestMapping("/findAccount")
public String findAccount(Integer accountId,String accountName) {
	System.out.println("查询了账户。。。。"+accountId+","+accountName);
	return "success";
POJO 类型作为参数
  • 实体类代码：
//账户信息
public class Account implements Serializable {
	private Integer id;
	private String name;
	private Float money;
	private Address address;
    //getters and setters
}
//地址的实体类
public class Address implements Serializable {
	private String provinceName;
	private String cityName;
	//getters and setters
}
  • jsp 代码：
<!-- pojo 类型演示 -->
<form action="account/saveAccount" method="post">
	账户名称：<input type="text" name="name" ><br/>
	账户金额：<input type="text" name="money" ><br/>
	账户省份：<input type="text" name="address.provinceName" ><br/>
	账户城市：<input type="text" name="address.cityName" ><br/>
	<input type="submit" value="保存">
</form>
  • 控制器代码：
@RequestMapping("/saveAccount")
public String saveAccount(Account account) {
	System.out.println("保存了账户。。。。"+account);
	return "success";
}
POJO 类中包含集合类型参数
  • 实体类代码：
//用户实体类
public class User implements Serializable {
	private List<Account> accounts;
	private Map<String,Account> accountMap;
	//getters and setters
}
  • jsp 代码：
<!-- POJO 类包含集合类型演示 -->
	账户 1 名称：<input type="text" name="accounts[0].name" ><br/>
	账户 1 金额：<input type="text" name="accounts[0].money" ><br/>
	账户 3 名称：<input type="text" name="accountMap['one'].name" ><br/>
	账户 3 金额：<input type="text" name="accountMap['one'].money" ><br/>
	<input type="submit" value="保存">
</form>
  • 控制器代码：
/**
* 更新账户
* @return
*/
@RequestMapping("/updateAccount")
public String updateAccount(User user) {
	System.out.println("更新了账户。。。。"+user);
	return "success";
}

请求参数乱码问题

  • post 请求方式：
    在 web.xml 中配置一个过滤器

     <!-- 配置 springMVC 编码过滤器 -->
        <filter>
            <filter-name>CharacterEncodingFilter</filter-name>
            <filter-class>
                org.springframework.web.filter.CharacterEncodingFilter
            </filter-class>
            <!-- 设置过滤器中的属性值 -->
            <init-param>
                <param-name>encoding</param-name>
                <param-value>UTF-8</param-value>
            </init-param>
            <!-- 启动过滤器 -->
            <init-param>
                <param-name>forceEncoding</param-name>
                <param-value>true</param-value>
            </init-param>
        </filter>
        <!-- 过滤所有请求 -->
        <filter-mapping>
            <filter-name>CharacterEncodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
  • 在 springmvc 的配置文件中可以配置，静态资源不过滤：
<!-- location 表示路径，mapping 表示文件，**表示该目录下的文件以及子目录的文件 -->
<mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/scripts/" mapping="/javascript/**"/>
  • get 请求方式：
    tomacat 对 GET 和 POST 请求处理方式是不同的，GET 请求的编码问题，要改 tomcat 的 server.xml 配置文件，如下：
<Connector	connectionTimeout="20000"	port="8080"
			protocol="HTTP/1.1" redirectPort="8443"/>

​ 改为：

<Connector connectionTimeout="20000" port="8080"
		   protocol="HTTP/1.1" redirectPort="8443"
		   useBodyEncodingForURI="true"/>
  • 如果遇到 ajax 请求仍然乱码，请把：
    useBodyEncodingForURI="true"改为 URIEncoding="UTF-8"即可。

自定义类型转换器

使用场景:

jsp 代码：

<!-- 特殊情况之：类型转换问题 -->
<a href="account/deleteAccount?date=2018-01-01">根据日期删除账户</a>

控制器代码：

/**
* 删除账户
* @return
*/
@RequestMapping("/deleteAccount")
public String deleteAccount(Date date) {
	System.out.println("删除了账户。。。。"+date);
	return "success";
}

因data数据的格式错误，所有运行结果将会是404-Bad Request

使用步骤
  1. 第一步：定义一个类，实现 Converter 接口，该接口有两个泛型
public interface Converter<S, T> {//S:表示接受的类型，T：表示目标类型
/**
*实现类型转换的方法
*/
	@Nullable
	T convert(S source);
}

/**
 * 自定义类型转换器
 */
public class StringToDateConverter implements Converter<String, Date> {
    /**
     * 用于把 String 类型转成日期类型
     */
    @Override
    public Date convert(String source) {
        DateFormat format = null;
        try {
            if(StringUtils.isEmpty(source)) {
                throw new NullPointerException("请输入要转换的日期");
            }
            format = new SimpleDateFormat("yyyy-MM-dd");
            Date date = format.parse(source);
            return date;
        } catch (Exception e) {
            throw new RuntimeException("输入日期有误");
        }
    }
}
  1. 第二步：在 spring 配置文件中配置类型转换器。
    spring 配置类型转换器的机制是，将自定义的转换器注册到类型转换服务中去。
<!-- 配置类型转换器工厂 -->
<bean id="converterService"
      class="org.springframework.context.support.ConversionServiceFactoryBean">
      
<!-- 给工厂注入一个新的类型转换器 -->
<property name="converters">

	<array>
    <!-- 配置自定义类型转换器 -->
		<bean class="cn.myp666.web.converter.StringToDateConverter"></bean>
	</array>

</property>
</bean>
  1. 第三步：在 annotation-driven 标签中引用配置的类型转换服务
<!-- 引用自定义类型转换器 -->
<mvc:annotation-driven
conversion-service="converterService"></mvc:annotation-driven>
使用 ServletAPI 对象作为方法参数

SpringMVC 还支持使用原始 ServletAPI 对象作为控制器方法的参数。支持原始 ServletAPI 对象有：

  • HttpServletRequest
  • HttpServletResponse
  • HttpSession
  • java.security.Principal
  • Locale
  • InputStream
  • OutputStream
  • Reader
  • Writer

我们可以把上述对象，直接写在控制的方法参数中使用。

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request,
        HttpServletResponse response,
        HttpSession session) {
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
        return "success";
}

SpringMVC的常用注解

RequestParam
  • 作用：
    把请求中指定名称的参数给控制器中的形参赋值。
  • 属性：
    • value：请求参数中的名称。
    • required：请求参数中是否必须提供此参数。默认值：true。表示必须提供，如果不提供将报错。
<!-- requestParams 注解的使用 -->
<a href="springmvc/useRequestParam?name=test">requestParam 注解</a>

@RequestMapping("/useRequestParam")
public String useRequestParam(@RequestParam("name")String username,
@RequestParam(value="age",required=false)Integer age){
        System.out.println(username+","+age);
        return "success";

RequestBody

  • 作用：
    用于获取请求体内容。直接使用得到是 key=value&key=value…结构的数据。
    get 请求方式不适用。

  • 属性：

    required：是否必须有请求体。默认值是:true。当取值为 true 时,get 请求方式会报错。如果取值为 false，get 请求得到null。

PathVaribale
  • 作用：
    用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，这个{id}就是 url 占位符。
    url 支持占位符是 spring3.0 之后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志。
  • 属性：
    value：用于指定 url 中占位符名称。
    required：是否必须提供占位符。
<!-- PathVariable 注解 -->
<a href="springmvc/usePathVariable/100">pathVariable 注解</a>



@RequestMapping("/usePathVariable/{uid}")
public String usePathVariable(@PathVariable("uid") Integer id){
        System.out.println(id);
        return "success";
}
RequestHeader

  • 作用：
    用于获取请求消息头。

  • 属性：

    • value：提供消息头名称
    • required：是否必须有此消息头
    @RequestMapping("/useRequestHeader")
public String useRequestHeader(@RequestHeader(value="Accept-Language",
        required=false)String requestHeader){
        System.out.println(requestHeader);
        return "success";
}
CookieValue

  • 作用：
    用于把指定 cookie 名称的值传入控制器方法参数。

  • 属性：

    • value：指定 cookie 的名称。
    • required：是否必须有此 cookie。
    @RequestMapping("/useCookieValue")
public String useCookieValue(@CookieValue(value="JSESSIONID",required=false) 
String cookieValue){
        System.out.println(cookieValue);
        return "success";
}
ModelAttribute
  • 作用：
    该注解是 SpringMVC4.3 版本以后新加入的。它可以用于修饰方法和参数。
    出现在方法上，表示当前方法会在控制器的方法执行之前，先执行。它可以修饰没有返回值的方法，也可以修饰有具体返回值的方法。出现在参数上，获取指定的数据给参数赋值。
  • 属性：
    value：用于获取数据的 key。key 可以是 POJO 的属性名称，也可以是 map 结构的 key。
  • 应用场景：
    当表单提交数据不是完整的实体类数据时，保证没有提交数据的字段使用数据库对象原来的数据。
    例如：
    我们在编辑一个用户时，用户有一个创建信息字段，该字段的值是不允许被修改的。在提交表单数据是肯定没有此字段的内容，一旦更新会把该字段内容置为 null，此时就可以使用此注解解决问题。
基于 Map 的应用场景示例 1：ModelAttribute 修饰方法不带返回值
  • 需求：
    修改用户信息，要求用户的密码不能修改
  • jsp 中的代码：
<!-- 修改用户信息 -->
<form action="springmvc/updateUser" method="post">
	用户名称：<input type="text" name="username" ><br/>
	用户年龄：<input type="text" name="age" ><br/>
	<input type="submit" value="保存">
</form>


/**
 * 查询数据库中用户信息
 * @param user
 */
@ModelAttribute
public void showModel(String username,Map<String,User> map) {
//模拟去数据库查询
        User user = findUserByName(username);
        System.out.println("执行了 showModel 方法"+user);
        map.put("abc",user);
        }
/**
 * 模拟修改用户方法
 * @param user
 * @return
 */
@RequestMapping("/updateUser")
public String testModelAttribute(@ModelAttribute("abc")User user) {
        System.out.println("控制器中处理请求的方法：修改用户："+user);
        return "success";
        }
/**
 * 模拟去数据库查询
 * @param username
 * @return
 */
private User findUserByName(String username) {
        User user = new User();
        user.setUsername(username);
        user.setAge(19);
        user.setPassword("123456");
        return user;
        }
SessionAttribute
  • 作用：
    用于多次执行控制器方法间的参数共享。
  • 属性：
    • value：用于指定存入的属性名称
    • type：用于指定存入的数据类型。
/**
 * SessionAttribute 注解的使用
 */
@Controller("sessionAttributeController")
@RequestMapping("/springmvc")
@SessionAttributes(value ={"username","password"},types={Integer.class})
public class SessionAttributeController {
    /**
     * 把数据存入 SessionAttribute
     * @param model
     * @return
     * Model 是 spring 提供的一个接口，该接口有一个实现类 ExtendedModelMap
     * 该类继承了 ModelMap，而 ModelMap 就是 LinkedHashMap 子类
     */
    @RequestMapping("/testPut")
    public String testPut(Model model){

        model.addAttribute("username", "泰斯特");

        model.addAttribute("password","123456");

        model.addAttribute("age", 31);

//跳转之前将数据保存到 username、password 和 age 中，因为注解@SessionAttribute 中有这几个参数
        return "success";

    }


    @RequestMapping("/testGet")

    public String testGet(ModelMap model){

        System.out.println(model.get("username")+";"+model.get("password")+";"+model.get("age")); 

        return "success";

    }


    @RequestMapping("/testClean")

    public String complete(SessionStatus sessionStatus){

        sessionStatus.setComplete();

        return "success";

    }
}
きょうま
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springmvc_day01
01-10
注解驱动:替我们显示的配置了最新版的处理器映射器和处理器适配器
springMVC_day01_入门
Jesson_study
09-06 360
springMVC是什么? 概念 表现层框架作用 接收参数 返回响应 Sprig Web MVC和Struts2都属于表现层的框架,它是Spring框架的一部分,我们可以从Spring的整体结构中看得出来,如下图： springMVC执行流程  用户请求——&gt;前端控制器DispatcherServlet——&gt;处理器映射器：判断你这个映射器是什么形式开发的（注解...
SpringMVC_day01
InLoadwetrust的博客
07-17 203
今日内容SpringMVC是隶属于Spring框架的一部分，主要是用来进行Web开发，是对Servlet进行了封装。对于SpringMVC我们主要学习如下内容:SpringMVC是处于Web层的框架，所以其主要的作用就是用来接收前端发过来的请求和数据然后经过处理并将处理的结果响应给前端，所以如何处理请求和响应是SpringMVC中非常重要的一块内容。REST是一种软件架构风格，可以降低开发的复杂性，提高系统的可伸缩性，后期的应用也是非常广泛。SSM整合是把咱们所学习的SpringMVC+Spring+Myb
SpringMvc_Day01
LOL111222333的博客
05-02 316
SpringMvc 入门第一个程序 1.创建工程 2.改 pom <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.8</maven.compiler.source&gt...
springmvc_day02_response
qq_43621053的博客
11-29 102
今天是从数据库中取出来数据然后显示在页面中。 首先从数据库中取出来的数据放入model中 ，然后就可以用 ${user.name}进行打印输出在页面中。 @RequestMapping("/testString") public String testString(Model model) { System.out.println("testString 执行了...
08_SPRINGMVC_DAY01
来自50年后的地球????博客
07-08 212
1. SpringMVC框架的作用 MVC = Model（数据模型） + View（视图） + Controller（控制器） SpringMVC框架主要解决了接收请求与处理响应的问题，也可以认为是解决了V-C交互的问题，与M其实没有关系。 在传统的Java EE的开发模式下，可能存在Servlet组件数量太多的问题，会导致项目的管理难度太大，且运行时，会有大量的Servlet对象长期占用内存的问题！ 另外，传统的Java EE开发模式下，数据的处理过程中代码量相对较大，而SpringMVC非常大极度的简
springmvc_day02
coderMonkey的博客
09-28 197
SpringMVC的请求和响应 SpringMVC的数据响应 01-SpringMVC的数据响应-数据响应方式(理解) 页面跳转 直接返回字符串 通过ModelAndView对象返回 2） 回写数据 直接返回字符串 返回对象或集合 02-SpringMVC的数据响应-页面跳转-返回字符串形式（应用） 03-SpringMVC的数据响应-页面跳转-返回ModelAndView形式1(应用) 在Controller中方法返回ModelAndView对象，并且设置视图名称 @RequestMapping(v
Java_SpringMVC_day01
SUIT THUG!的博客
09-19 130
回顾 1，AOP（注解） 常用的注解 @Aspect 声明切面 @Pointcut 定义切入点表达式 @Before 前置通知 @After 后置通知 @AfterReturning 返回后通知 @AfterThrowing 异常通知 @Around 环绕通知 开启aop注解驱动： <aop:aspectj-autoproxy /> aop原理： 默认是判断是否实现接口，实现使用的是jdk动态代理，没有实现使用CGLIB代理。 我们也可以通过设置使无论是
SpringMVC_day01_c01SpringMVC三层架构介绍
ZM つ小灰灰的成长的博客
06-08 3866
一、三层架构简介      顾名思义，三层架构分为三层，分别是“数据访问层”、“业务逻辑层”和“表示层”。      数据访问层（持久层）：数据访问层在作业过程中访问数据系统中的文件，实现对数据库中数据的读取保存操作。      表示层：主要功能是显示数据和接受传输用户的数据，可以在为网站的系统运行提供交互式操作界面，表示层的应用方式比较常见，例如Window
springmvc_day01_01_start.zip
12-29
springmvc入门通过超链接请求一个控制器（servlet）实现页面跳转详情关注博客会有讲解。写什么才能凑够五十字呢哈哈哈哈哈哈
springMVC_day01.xmind
09-10
SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 中。 SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring...
springmvc_day01_start.zip
03-11
SpringMVC入门实例，从搭建环境，到配置文件的编写解释，到代码的编写，非常详细，非常基础的入门项目，欢迎下载浏览。
springmvc_day01.rar
08-15
springmvc+mybatis+spring整合的一个比较常规性的模板
基于go语言的类python生态中LangChain的LLMs接口框架，
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： 简洁性：Go语言的语法简单直观，易于学习和使用。它避免了复杂的语法特性，如继承、重载等，转而采用组合和接口来实现代码的复用和扩展。 高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性：Go语言具有强大的类型系统和内存管理机制，能够减少运行时错误和内存泄漏等问题。它还支持编译时检查，可以在编译阶段就发现潜在的问题。 标准库：Go语言的标准库非常丰富，包含了大量的实用功能和工具，如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现，而无需花费太多时间在底层功能的实现上。 跨平台：Go语言支持多种操作系统和平台，包括Windows、Linux、macOS等。它使用统一的构建系统（如Go Modules），可以轻松地跨平台编译和运行代码。 开源和社区支持：Go语言是开源的，具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之，Go语言是一种简单、高效、安全、并发的编程语言，特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言，并且需要处理大量的并发请求和数据，那么Go语言可能是一个不错的选择。
基于go的轻量化key-value服务.zip
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： 简洁性：Go语言的语法简单直观，易于学习和使用。它避免了复杂的语法特性，如继承、重载等，转而采用组合和接口来实现代码的复用和扩展。 高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性：Go语言具有强大的类型系统和内存管理机制，能够减少运行时错误和内存泄漏等问题。它还支持编译时检查，可以在编译阶段就发现潜在的问题。 标准库：Go语言的标准库非常丰富，包含了大量的实用功能和工具，如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现，而无需花费太多时间在底层功能的实现上。 跨平台：Go语言支持多种操作系统和平台，包括Windows、Linux、macOS等。它使用统一的构建系统（如Go Modules），可以轻松地跨平台编译和运行代码。 开源和社区支持：Go语言是开源的，具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之，Go语言是一种简单、高效、安全、并发的编程语言，特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言，并且需要处理大量的并发请求和数据，那么Go语言可能是一个不错的选择。
蓝桥杯嵌入式组第十二届国赛程序题
05-23
蓝桥杯嵌入式组第十二届国赛程序题
shufflenet模型-python语言pytorch框架训练识别樱桃新鲜度-不含数据集图片-含逐行注释和说明文档.zip
最新发布
05-23
shufflenet模型_python语言pytorch框架训练识别樱桃新鲜度-不含数据集图片-含逐行注释和说明文档 本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 如果有环境安装不会的，可自行网上搜索如何安装python和pytorch,这些环境安装都是有很多教程的，简单的 环境需要自行安装,推荐安装anaconda然后再里面推荐安装python3.7或3.8的版本，pytorch推荐安装1.7.1或1.8.1版本 首先是代码的整体介绍 总共是3个py文件，十分的简便 且代码里面的每一行都是含有中文注释的,小白也能看懂代码 然后是关于数据集的介绍。 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 在数据集文件夹下是我们的各个类别,这个类别不是固定的，可自行创建文件夹增加分类数据集 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行
bleder 教室学校学生教育室办公室考试
05-23
bleder 教室学校学生教育室办公室考试
/springmvc_war_exploded/add/1/2 保留倒数第二个/后的内容
07-27
String url = "/springmvc_war_exploded/add/1/2"; int secondLastSlashIndex = url.lastIndexOf('/', url.lastIndexOf('/') - 1); String content = url.substring(secondLastSlashIndex + 1); System.out.println...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值