SpringMVC

最新推荐文章于 2024-08-03 17:05:14 发布
最新推荐文章于 2024-08-03 17:05:14 发布
阅读量420 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64537997/article/details/123050534
版权

第一章：Java web的发展历史

一.Model I和Model II

1.Model I开发模式

Model1的开发模式是：JSP+JavaBean的模式，它的核心是Jsp页面，在这个页面中，Jsp页面负责整合页面和JavaBean（业务逻辑），而且渲染页面，它的基本流程如下：

这样的设计模式到这一个jsp页面负责了视图的展示和业务流程的控制高度耦合的结果是Jsp代码十分复杂，后期维护困难！

2.Model II开发模式

在Model II的模式下。利用jsp页面、servlet和JavaBean组件分工协作共同完成系统的所有任务。其中jsp负责数据显示逻辑任务，servlet负责程序的流程控制任务，JavaBean负责处理业务逻辑任务。它的基本流程如下：

Model2：相对于Model1来说，职责分工更为明确，在Model1的基础上，抽取了Servlet层，体现了一个分层的思想，适合大型的项目开发！（当时的评判标准是适合大型项目开发的，现在看起来已经过时了！）

二. MVC模式

Spring mvc是基于Spring的一个模块，专门做web开发，可以理解为是Servlet的升级。在Spring MVC框架当中，Controller替代Servlet担负控制器的职能。

M：指model:模型层，指工程当中的Java Bean,作用是处理数据。

Java Bean分两类：

  • 一类是实体类Bean:专门存储业务数据；
  • 一类为业务处理Bean:指Servlet或Dao对象，专门处理业务逻辑和数据。

V:View,视图层指项目当中的html或jsp等页面，作用是与用户进程交互，展示数据。

C:Contoller,控制层，指工程当中的servlet,作用是接受请求和响应数据。

MAC思想不是语言所特有的设计模式，也不是web应用所特有的思想，而是一种规范。MVC思想将一个应用分成三个基本部分：Model(模型)、View(视图)和Controller(控制器)，这三个部分以最少的耦合协同工作，从而提高了应用的可扩展性和可维护性。他们三者的关系如下图所示。

 

第二章：SpringMVC的入门案例

一. SpringMVC的入门程序

1、搭建spring MVC

①：创建WEB工程，引入开发的jar包

②：具体的坐标如下

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

    <dependencies>

        <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>

        <!--SpringMVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--servlet API-->
        <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.2</version>
            <scope>provided</scope>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.10</version>
        </dependency>

    </dependencies>

③：添加web模块

 

 

 

 

④：配置DispatcheServlet

Spring MVC是基于原生的servlet,通过强大的前端控制器DispatcheServlet，对请求和响应进行统一处理。

Spring MVC的本质就是一个servlet,是对原生的servlet进行了封装。在以前我们浏览器的每一次请求都需要我们写一个对应的servlet,现在我们只需要将浏览器的请求和响应交给DispatcheServlet进行统一的处理。

在web.xml配置文件中核心控制器DispatcherServlet

<!‐‐配置前端控制器，对浏览器发送的请求进行统一处理‐‐>
<servlet>
    <servlet‐name>dispatcherServlet</servlet‐name>
    <servlet‐class>org.springframework.web.servlet.DispatcherServlet</servlet‐class>
    <!‐‐加载springmvc.xml配置文件的位置和名称，配置的是Spring配置‐‐>
    <init‐param>
    	<!--contextConfigLocation:上下文配置路径，固定值-->
    	<param‐name>contextConfigLocation</param‐name>
     	<!--classpath:类路径，值得是Java和resources文件夹-->
      	<!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面-->
    	<param‐value>classpath:springmvc.xml</param‐value>
    </init‐param>
    <!‐‐配置启动加载‐‐>
    <load‐on‐startup>1</load‐on‐startup>
</servlet>
<servlet‐mapping>
    <servlet‐name>dispatcherServlet</servlet‐name>
    <url‐pattern>*.do</url‐pattern>
</servlet‐mapping>

 

 

 编写index.html页面

<html>
<head>
<meta charset="utf-8">
<title>入门程序</title>
</head>
<body>
<h3>入门</h3><a href="/hello.do" >入门程序</a>
</body>
</html>

编写suc.html页面（INF/pages/suc.jsp）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>成功</title>
</head>
<body>
<h3>入门成功了2...</h3>
</body>
</html>

编写Controller类和方法

package cn.tx.demo1;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

// 把当前类交给IOC容器进行管理
@Controller
public class HelloController {
/**
* 处理超链接发送出来的请求
* @return
*/
// 配置映射的配置
@RequestMapping(path = "/hello.do")
        public String sayHello(){
        System.out.println("入门方法执行了2...");
        // 跳转的JSP页面的路径，默认使用的是请求的转发
        // return "/WEB‐INF/pages/suc.jsp";
        // 配置了视图解析器后，写法
        return "suc";
    }
}

编写springmvc.xml的配置文件

<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.tx"></context:component‐scan>
<!‐‐ 配置视图解析器 ‐‐>
<!-- 定义跳转的文件的前后缀 ，视图模式配置-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
    <property name="prefix" value="/html/" />
    <property name="suffix" value=".html" />
</bean>
<!-- 配置spring开启注解mvc的支持  默认就是开启的 ，要想让其他组件（不包含映射器、适配器、处理器）生效就必须需要配置了-->
<mvc:annotation-driven></mvc:annotation-driven>
</beans>

启动Tomcat服务器，进行测试。

3. 入门案例的执行过程分析

入门案例的执行流程：

1. 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，就会加载springmvc.xml配置文件。

2. 开启了注解扫描，那么HelloController对象就会被创建。

3. 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配@RequestMapping注解找到执行的具体方法。

4. 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件。

5. Tomcat服务器渲染页面，做出响应。

SpringMVC官方提供图形

入门案例中的组件分析

1. 前端控制器（DispatcherServlet）

2. 处理器映射器（HandlerMapping）

3. 处理器（Handler）

4. 处理器适配器（HandlAdapter）

5. 视图解析器（View Resolver）

6. 视图（View）

4. RequestMapping注解

RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系。RequestMapping注解可以作用在方法和类上。

1. 作用在类上：第一级的访问目录。

2. 作用在方法上：第二级的访问目录。

3. 细节：路径可以不编写 / 表示应用的根目录开始。

RequestMapping的属性：

1. path 指定请求路径的url。

2. value value属性和path属性是一样的。

3. mthod 指定该方法的请求方式。

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping(path = "/role") // 一级请求路径
public class RoleController {
    /**
     * /role/save.do
     * method="当前方法允许请求方式能访问"
     * params="请求路径上传参数"
     * @return
     */
    @RequestMapping(path = "/save.do",method = {RequestMethod.GET})
    public String save(){
        System.out.println("保存角色...");
        return "suc";
    }
    @RequestMapping(value = "/delete.do")
    public String delete(){
        System.out.println("删除角色...");
        return "suc";
    }
}

第三章：请求参数的绑定

请求参数的绑定说明：

1. 绑定机制：

(1). 表单提交的数据都是k=v格式的，例如：username=haha&password=123。

(2). SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的。

(3). 要求：提交表单的name和参数的名称是相同的。

2. 支持的数据类型:

(1). 基本数据类型和字符串类型。

(2). 实体类型（JavaBean）。

(3). 集合数据类型（List、map集合等）。

      基本数据类型和字符串类型：

             1. 提交表单的name和参数的名称是相同的。

             2. 区分大小写。

       实体类型（JavaBean）：

             1. 提交表单的name和JavaBean中的属性名称需要一致。

             2. 如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写成：对                   象.属性 例如：address.name。

        给集合属性数据封装：

             1. JSP页面编写方式：list[0].属性。

jsp代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>请求参数绑定入门程序</h1>
    <form action="/user/save.do" method="get">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="submit"/>
    </form>
    <h1>请求参数绑定入门程序（封装到实体类）</h1>
    <form action="/user/save1.do" method="post">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="submit"/>
    </form>
    <h1>请求参数绑定入门程序（封装到实体类）</h1>
    <form action="/user/save2.do" method="post">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="text" name="account.money"/><br/>
        <input type="submit"/>
    </form>
    <h1>请求参数绑定入门程序（存在list集合）</h1>
    <form action="/user/save3.do" method="post">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="text" name="account.money"/><br/>
        <input type="text" name="accounts[0].money"/><br/>
        <input type="text" name="accounts[1].money"/><br/>
        <input type="submit"/>
    </form>
</body>
</html>

Javabean代码

package com.qcby.entity;

import java.io.Serializable;
import java.util.List;

public class User implements Serializable {
    private String username;
    private Integer age;
    private Account account;
    private List<Account> accounts;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", account=" + account +
                ", accounts=" + accounts +
                '}';
    }
}
package com.qcby.entity;

import java.io.Serializable;

public class Account implements Serializable {
    private Double money;

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "money=" + money +
                '}';
    }
}

controller代码

package com.qcby.web;

import com.qcby.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/save.do")
    public String save(String username,Integer age){
        System.out.println(username);
        System.out.println(age);
        return "suc";
    }

    @RequestMapping("/save1.do")
    public String save1(User user){
        System.out.println(user);
        return "suc";
    }

    @RequestMapping("/save2.do")
    public String save2(User user){
        System.out.println(user);
        return "suc";
    }

    @RequestMapping("/save3.do")
    public String save3(User user){
        System.out.println(user);
        return "suc";
    }
}

post请求中参数中文乱码的解决方案：在web.xml中配置Spring提供的过滤器类。

<!‐‐ 配置过滤器，解决中文乱码的问题 ‐‐>
<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>
</filter>
<filter‐mapping>
<filter‐name>characterEncodingFilter</filter‐name>
<url‐pattern>/*</url‐pattern>
</filter‐mapping>

在控制器中使用原生的ServletAPI对象：

1. 只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象。

@RequestMapping("/save6.do")
public String save6(HttpServletRequest request, HttpServletResponse response){
    System.out.println(request);
    // 获取到HttpSession对象
    HttpSession session = request.getSession();
    System.out.println(session);
    System.out.println(response);
    return "suc";
}

第四章：常用的注解

1. RequestParam注解

1. 作用：把请求中的指定名称的参数传递给控制器中的形参赋值

2. 属性：

        1. value：请求参数中的名称。

        2. required：请求参数中是否必须提供此参数，默认值是true，必须提供。

3. 代码如下：

package com.qcby.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/dept")
public class DeptController {
    @RequestMapping("/save")
    public String save(@RequestParam(value = "username",required = false) String name){
        System.out.println(name);
        return "suc";
    }
}

访问：http://localhost:8080/SpringMVCDemo/dept/save.do?username=张三

3. PathVaribale注解

     1. 作用：拥有绑定url中的占位符的。例如：url中有/delete/{id}，{id}就是占位符。

     2. 属性：

          value：指定url中的占位符名称。

     3. Restful风格的URL：

          1. 请求路径一样，可以根据不同的请求方式去执行后台的不同方法。

          2. restful风格的URL优点：

               1. 结构清晰

               2. 符合标准

               3. 易于理解

               4. 扩展方便

 4. 代码如下：

package com.qcby.demo3;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
// @RequestMapping("/emp")
public class EmpController {
    /**
    * 保存
    * @return
    */
    @RequestMapping(path = "/emp",method = RequestMethod.POST)
    public String save(){
        System.out.println("保存员工...");
        return "suc";
    }/**
    * 查询所有
    * @return
    */
    @RequestMapping(path = "/emp",method = RequestMethod.GET)
    public String findAll(){
        System.out.println("查询员工...");
        return "suc";
    }
    /**
    * 查询所有
    * @return
    */
    @RequestMapping(path = "/emp/{id}",method = RequestMethod.GET)
    public String findById(@PathVariable(value = "id") Integer id){
        System.out.println("通过id查询员工..."+id);
        return "suc";
    }
}

5. 修改前端控制器的配置文件：

<!‐‐配置前端控制器‐‐>
<servlet>
<servlet‐name>dispatcherServlet</servlet‐name>
<servlet‐class>org.springframework.web.servlet.DispatcherServlet</servlet‐class>
<!‐‐加载springmvc.xml配置文件，配置的是Spring配置‐‐>
<init‐param>
<param‐name>contextConfigLocation</param‐name>
<param‐value>classpath:springmvc.xml</param‐value>
</init‐param>
<!‐‐配置启动加载‐‐>
<load‐on‐startup>1</load‐on‐startup>
</servlet>
<!‐‐
<servlet‐mapping>
<servlet‐name>dispatcherServlet</servlet‐name>
<url‐pattern>*.do</url‐pattern>
</servlet‐mapping>
‐‐>
<servlet‐mapping>
<servlet‐name>dispatcherServlet</servlet‐name>
<url‐pattern>/</url‐pattern>
</servlet‐mapping>

4. RequestHeader注解

     1. 作用：获取指定请求头的值。

     2. 属性：

          value：请求头的名称。

     3. 代码如下：

/**
* RequestHeader 获取请求头的值
* @return
*/
@RequestMapping("/save3.do")
public String save3(@RequestHeader(value = "Accept") String header){
    System.out.println("Accept请求头的值："+header);
    return "suc";
}

5. CookieValue注解：

      1. 作用：用于获取指定cookie的名称的值。

      2. 属性：

            value：cookie的名称。

      3. 代码

/**
* CookieValue 获取到cookie中的值
* @return
*/
@RequestMapping("/save4.do")
public String save4(@CookieValue(value = "JSESSIONID") String cookie){
    System.out.println("值："+cookie);
    return "suc";
}

Beau Wang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringMVC篇
qq_46423017的博客
10-28 1313
1、SpringMVC的工作流程（重点） 2、SpringMVC的主要组件 3、什么是SpringMVC？简单介绍下你对SpringMVC的理解 4、SpringMVC的优点 5、SpringMVC常用的注解 6、SpringMVC怎么设定重定向和转发的 7、SpringMVC和Struts2的区别有哪些？ 8、如何解决POST请求中文乱码问题? 9、GET请求乱码怎么解决 10、springMVC里面拦截器是怎么写？ 11、SpringMvc的控制器是不是单例模式，如果是，有什么问题，怎么解决？
springMVC介绍
qq_45796208的博客
01-16 2538
springMVC简介 springMVC又 叫Spring web mvc。是Spring框架中的一部分，是Spring3.0后发布的。 SpringMVC框架的优点 1、基于MVC架构模式：MVC架构模式 2、容易理解上手快，使用简单：可以开发一个注解的SpringMVC项目，SpringMVC也是轻量级的框架，jar包很小，不依赖特定的接口和类。 3、作为Spring的一部分，能够使用Spring框架的IOC容器和Aop编程。方便整合Strtus、MyBatis、Hibernate、JPA等
SpringMVC常见面试题总结（超详细回答）
热门推荐
张维鹏的博客
07-08 57万+
1、什么是Spring MVC ？简单介绍下你对springMVC的理解? SpringMVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。 2、SpringMVC的流程？ （1）用户发送请...
SpringMvc
qq_45009608的博客
06-08 718
SpringMVC是一种基于Java实现MVC模型的轻量级Web框架（代替JavaWeb的表现层Servlet) 优点1.创建Maven项目 2.补全目录结构 3.导入jar包 将pom.xml中多余的内容删除掉，再添加SpringMVC需要的依赖 4.创建配置类 5.创建Controller类 6.使用配置类替换web.xml 将web.xml删除，换成ServletContainersInitConfig web.xml是管理servlet的 7.配置Tomcat环境 注意事项 Spri
SpringMVC简介
sssxlxwbwz的博客
03-26 2160
一、MVC简介 MVC是一种软件架构地思想，将软件按照模型(Model)、视图(View)、控制器(Control)来划分。
SpringMVC的数据请求
楠黎倾风的博客
12-27 3万+
SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。//将日期字符串转换成日期对象 返回 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");try {} }}
springmvc详解
刘豪豪的博客
07-19 2084
说完spring，那么来说下springmvc，还是什么是springmvc？ springmvc是spring框架的一个模块，基于 MVC 的一个框架，springmvc和spring无需通过中间整合层进行整合。 springmvc是一个基于mvc的web框架。 springmvc 表现层：方便前后端数据的传输 Spring MVC 拥有控制器，作用跟Struts类似，接收外部请求，解析参数传给服务层 MVC是指，C控制层，M模块层，V显示层这样的设计理念，而SSM框架里面SPRING MVC本身就是MV
【SpringMVC】| SpringMVC 入门
m0_61933976的博客
04-25 3316
【SpringMVC】| SpringMVC 入门
SpringMVC原理
笔记别偷看
06-19 5125
Spring MVC的功能组件 Spring通过一系列组件实现功能，这些组件包括DispatcherServlet（前端控制器）、HandlerMapping（处理器映射器）Handler(处理器)、HandlAdapter（处理器适配器）、ViewResolver（视图解析器）等。 DispatcherServlet（前端控制器） 前端控制器负责拦截客户端请求并分发给其他组件，它是整个流程控制的中心，负责调度其他组件的执行，降低各组件之间的耦合，提升整体效率。前端控制器由框架提供，在程序运行过程中自动实
SpringMVC 入门
AwayFuture的博客
03-23 565
SpringMVC学习的源代码，学习的每个知识点都在注释中讲解了，详细请CLICK我的GitHub：Go to AwayFuture’s GitHub
SpringMVC demo 完整源码实例下载
05-02
SpringMVC是一款强大的Java web开发框架，用于构建高效、可维护的Web应用程序。在这个"SpringMVC demo 完整源码实例下载"中，我们能够深入理解并学习SpringMVC的核心概念和实际应用。 首先，SpringMVC是Spring框架...
springmvc思维导图
07-25
springmvc的概念、springmvc的运行原理（前端控制器、处理器映射器、处理器适配器、处理器、视图解析器）、同步请求的方式（ModelAndView、String、无返回值、默认的绑定值）、异步请求的注解、请求参数的封装（简单...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
springMVC学习
03-11
SpringMVC 学习指南 SpringMVC 是 Spring 框架中的一个 web 组件，它提供了丰富的功能来构建稳健的 web 应用。 SpringMVC 的核心思想是基于每个逻辑和功能是高可配置的架构和设计的。下面是 SpringMVC 的学习指南：...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 626
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
最新发布
m0_74283290的博客
08-03 652
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 546
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
JavaSE面向对象进阶
qq_45348840的博客
07-30 495
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
SpringMVC注解配置详解
"SpringMVC详解及注解说明文档，涵盖了基于注解的配置，Spring框架集成，以及如何利用注解实现IoC功能。" 在Java开发领域，SpringMVC是Spring框架的一个重要组件，用于构建Web应用程序。它遵循模型-视图-控制器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Beau Wang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值