SpringMVC

Spring Web MVC 是一种基于Java 的实现了Web MVC 设计模式的请求驱动类型的轻量级Web 框架，即使用了MVC 架构模式的思想，将 web 层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC 也是要简化我们日常Web 开发的。

配置模版

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

    <!--   组件扫描  扫描service和mapper-->
    <context:component-scan base-package="com.dong.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

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


</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
          http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--配置DispatchServlet  -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--DispatcherServlet要绑定spring的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>

        <!--设置启动级别: 1        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有请求都会被springmvc拦截  -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
        <!-- 映射路径为 / 【不要写 /* 会404】-->
    </servlet-mapping>


</web-app>

MVC

Model（模型） - 模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器。
View（视图） - 视图代表模型包含的数据的可视化。
Controller（控制器） - 控制器作用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。

中心控制器

DispatcherServlet

以前java + servlet + jsp一个请求就要配置一个和但现在通过加一层DispatcherServlet让他选择哪个servlet

第一个HelloSpringMVC程序

导包

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>

项目结构

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!--配置DispatchServlet  -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--DispatcherServlet要绑定spring的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>

        <!--设置启动级别: 1        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
        <!-- 映射路径为 / 【不要写 /* 会404】-->
    </servlet-mapping>

</web-app>

springmvc-servlet.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"
        xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--处理器映射器 -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <bean id="/hello" class="com.dong.controller.HelloController"/>

</beans>

HelloController

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();

        //业务代码
        String result = "业务的返回值";
        mv.addObject("msg",result);

        //视图跳转
        mv.setViewName("test");

        return mv;
    }
}

test.jsp

<%@page pageEncoding="UTF-8" contentType="text/html; UTF-8" isELIgnored="false" %>
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>测试</title>
</head>
<body>

${msg}

</body>

SpringMVC原理

前端控制器就是 DispatcherServlet

用户发起请求到前端控制器,前端控制器生成代理请求个实际控制器,实际控制器创建数据模型,访问数据库,在将这个数据模型给实际控制器,实际控制器在将这个数据模型返回给前端控制器,前端控制器根据数据渲染视图,在将这个视图返回给用户

工作原理描述如下:

用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获，DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心；

我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

如上url拆分成三部分：

http://localhost:8080服务器域名

SpringMVC部署在服务器上的web站点

hello表示控制器

通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器；
DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，DispatcherServlet调用HandlerMapping（处理映射器）查找Handler。
HandlerExecution表示查找到的具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等；
HandlerAdapter表示处理器适配器，其按照特定的规则去适配Handler（也就是Controller）。
Handler让具体的Controller执行，
Controller执行完成后，向HandlerAdapter返回一个ModelAndView对象，里面有具体的执行信息；
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet；
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名；

解析器做的事情
- 获取ModelAndView的数据
- 解析ModelAndView的视图名字
- 拼接视图名，找到对应的视图
- 将数据渲染到这个视图上
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图
最后将渲染结果返回给客户端。

使用注解开发

配置

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
          http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--配置DispatchServlet  -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--DispatcherServlet要绑定spring的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>

        <!--设置启动级别: 1        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有请求都会被springmvc拦截  -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
        <!-- 映射路径为 / 【不要写 /* 会404】-->
    </servlet-mapping>


</web-app>

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

    <!--   组件扫描  扫描service和mapper-->
    <context:component-scan base-package="com.dong.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

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


</beans>

控制器

//@RequestMapping("/hello") 如果这里也加那访问地址就是http://localhost:8080/hello/hello   类 / 方法上
@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model) {
        //封装数据
        model.addAttribute("msg", "Hello World");

        return "hello";//被视图解析器处理,就是经过拼接字符串得到jsp地址 /WEB-INF/jsp/hello.jsp
    }
}

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

${msg}

</body>
</html>

开启tomcat,访问http://localhost:8080/hello

URL传参

普通风格

RestFul风格

普通

@RequestMapping("/add")
public String test1(int a, int b, Model model) {
    int result = a + b;
    model.addAttribute("msg", result);
    return "test";
    //当访问http://localhost:8080/add?a=1&b=2 这个地址时会把a=1&b=2传入到这处理
}

RestFul

@RequestMapping("/add/{a}/{b}")
public String test2(@PathVariable int a, @PathVariable int b, Model model) {
    int result = a + b;
    model.addAttribute("msg", result);
    return "test";
    //当加了@PathVariable 这个注解(路径变量)
    //当访问http://localhost:8080/add/1/2 这个地址时会把1传到参数a 2传到参数b  处理
}

指定提交方式

@RequestMapping(value = "/add/{a}/{b}", method = RequestMethod.GET)
public String test3(@PathVariable int a, @PathVariable int b, Model model) {
    int result = a + b;
    model.addAttribute("msg", result);
    return "test";
    //method = RequestMethod.GET 指定GET请求方式
}

使用注解指定提交方式

@GetMapping("/add/{a}/{b}")
public String test4(@PathVariable int a, @PathVariable int b, Model model) {
    int result = a + b;
    model.addAttribute("msg", result);
    return "test";
    //method = RequestMethod.GET 指定GET请求方式
}

除了GetMapping还有

@GetMapping
@PostMapping
@DeleteMapping
@PutMapping

URL传递的参数与方法参数名不一致问题

    @RequestMapping("/t2")
    public String test2(@RequestParam("username") String name, Model model) {
        model.addAttribute("msg", name);
        return "test";
        //只要加上注解@RequestParam
        //http://localhost:8080/user/t1?username=小李 就能读取到了

    }

传递的是一个对象

    @RequestMapping("/t3")
    public String test3(User user, Model model) {
        model.addAttribute("msg", user);
        return "test";
        //http://localhost:8080/user/t3?id=1&name=小李&age=22 能被封装到User这个对象中去  User{id=1, name='小李', age=22}
        //注意: User的属性名必须个URL携带的参数名一致,否则user属性的值为null

        //http://localhost:8080/user/t3?id=1&username=小李&age=22    User{id=1, name='null', age=22}
    }

重定向和转发

没有视图解析器

使用spring的重定向和转发之前需要把视图解析器取消

重定向

@RequestMapping("/nrf/r")
public String Redirects() {

//        return "/index.jsp";
    return "redirect:/index.jsp";
}

@RequestMapping("/nrf/f")
public String forward() {

    return "forward:/WEB-INF/rf/forward.jsp";
}

有视图解析器

重定向

    @RequestMapping("/yrf/r")
    public String YRedirects() {

        return "redirect:/index.jsp";
    }

    @RequestMapping("/yrf/f")
    public String Yforward() {

        return "test";
    }

乱码问题

问题描述

通过一个表单提交数据到后台处理并打印出来

<form method="POST" action="/charset">
    <input type="text" name="name"/>
    <input type="submit"/>
</form>

    @RequestMapping("/charset")
    public String test(String name, Model model) {
        System.out.println("前端传递的参数" + name);
        model.addAttribute("msg", name);

        return "test";
    }

表单提交许忆晓

结果发现乱码前端显示为:

è®¸å¿æ

解决方法一:添加过滤器(老servlet的方式)

public class CharSetFilter implements Filter {
    @Override
    public void destroy() {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }
}

在web.xml中

  <!--注册Filter  -->
  <filter>
    <filter-name>charset</filter-name>
    <filter-class>com.dong.filter.CharSetFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>charset</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

解决方式二:(通过spring框架)
在web.xml中

  <filter>
    <filter-name>SpringEncoding</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>SpringEncoding</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

JSON

JSON 指的是 JavaScript 对象表示法
JSON 是轻量级的文本数据交换格式
JSON 独立于语言：JSON 使用 Javascript语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。目前非常多的动态（PHP，JSP，.NET）编程语言都支持 JSON
JSON 具有自我描述性，更易理解

{ "name":"google" , "url":"www.google.com" }

导包

        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.18.1</version>
        </dependency>

前端请求一个地址,返回一个java对象的json

普通json

    @RequestMapping("j1")
    @ResponseBody// 只要加了这个注解就不会走视图解析器,会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user = new User(1,"小明",45);

        String json = mapper.writeValueAsString(user);

        return json;
    }

虽然是json格式但是乱码{"id":1,"name":"??","age":45}

json乱码问题

需要在springmvc-servle.xmlt配置

<!--配置json乱码问题    -->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8".
            </bean>

            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

集合json

    @RequestMapping("j2")
    @ResponseBody// 只要加了这个注解就不会走视图解析器,会直接返回一个字符串
    public String json2() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user1 = new User(1,"小明",45);
        User user2 = new User(2,"小董",22);
        User user3 = new User(3,"小张",34);
        User user4 = new User(4,"小化",23);
        User user5 = new User(5,"小李",25);

        List<User> users = new ArrayList<User>();
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        users.add(user5);


        String json = mapper.writeValueAsString(users);

        return json;
    }

[{"id":1,"name":"小明","age":45},{"id":2,"name":"小董","age":22},{"id":3,"name":"小张","age":34},{"id":4,"name":"小化","age":23},{"id":5,"name":"小李","age":25}]

时间json

    @RequestMapping("j3")
    @ResponseBody// 只要加了这个注解就不会走视图解析器,会直接返回一个字符串
    public String json3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        Date date = new Date();



        String json = mapper.writeValueAsString(date);

        return json;
    }

返回的时时间戳 1733927518274

要按格式返回

    @RequestMapping("j4")
    @ResponseBody// 只要加了这个注解就不会走视图解析器,会直接返回一个字符串
    public String json4() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String json = mapper.writeValueAsString(sdf.format(date));
        return json;
    }

"2024-12-11 22:34:18"

FastJson

Fastjson 是一个阿里巴巴开发的Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。

    @RequestMapping("j5")
    @ResponseBody// 只要加了这个注解就不会走视图解析器,会直接返回一个字符串
    public String json5() throws JsonProcessingException {
        //创建一个对象
        User user1 = new User(1,"小明",45);
        User user2 = new User(2,"小董",22);
        User user3 = new User(3,"小张",34);
        User user4 = new User(4,"小化",23);
        User user5 = new User(5,"小李",25);

        List<User> users = new ArrayList<User>();
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        users.add(user5);

        String json = JSON.toJSONString(users);
        return json;
    }

[{"age":45,"id":1,"name":"小明"},{"age":22,"id":2,"name":"小董"},{"age":34,"id":3,"name":"小张"},{"age":23,"id":4,"name":"小化"},{"age":25,"id":5,"name":"小李"}]

Ajax技术

异步请求

在不刷新网页的情况下请求

使用前需要导入jquery的cdn

<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>

刷新表格

后台

@RequestMapping("/a2")
    @ResponseBody  // 告诉 Spring 自动将返回值转换成 JSON 格式
    public List<User> a2(String param) {
        System.out.println(param);

        List<User> list = new ArrayList<>();

        User user1 = new User(1, "小张", 32);
        User user2 = new User(2, "小明", 45);
        User user3 = new User(3, "小李", 34);

        list.add(user1);
        list.add(user2);
        list.add(user3);

        return list;
    }
    /*
    * 需要导入依赖
    * <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.14.2</version>  <!-- 使用合适的版本 -->
    </dependency>
*/

前端

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>异步加载数据</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>

    <script>
        function flush(){
            // 发起请求
            $.ajax({
                url: 'http://localhost:8080/a2',  // 访问控制器的方法
                type: 'GET',  // 请求方法是 GET
                data: {
                    param: "参数"
                },
                success: function(data) {
                    console.log("响应数据：", data);  // 在控制台打印返回的 JSON 数据

                    // 清空现有的表格内容
                    $('table tbody').empty();

                    // 遍历返回的数据并动态生成表格行
                    $.each(data, function(index, item) {
                        // 创建一行（tr）
                        var row = $('<tr></tr>');

                        // 为每个数据项创建一个单元格（td）并添加到行中
                        row.append('<td>' + item.id + '</td>');
                        row.append('<td>' + item.name + '</td>');
                        row.append('<td>' + item.age + '</td>');

                        // 将创建的行添加到表格的 tbody 中
                        $('table tbody').append(row);
                    });
                },
                error: function(xhr, status, error) {
                    console.log("请求失败：", error);  // 处理请求失败的情况
                }
            });
        }
    </script>

    <style>
        /* 表格样式 */
        table {
            width: 100%; /* 表格宽度 */
            border-collapse: collapse; /* 边框合并 */
            text-align: left; /* 文本左对齐 */
        }
        th, td {
            padding: 8px; /* 单元格内边距 */
            border: 1px solid #ddd; /* 单元格边框 */
        }
        th {
            background-color: #f2f2f2; /* 表头背景色 */
        }
        tr:nth-child(even) {
            background-color: #f9f9f9; /* 偶数行背景色 */
        }
        tr:hover {
            background-color: #eaeaea; /* 鼠标悬停行背景色 */
        }
    </style>
</head>
<body>
<input type="button" value="加载数据" onclick="flush()">

<table border="1" id="table">
    <thead>
    <tr>
        <td>ID</td>
        <td>姓名</td>
        <td>年龄</td>
    </tr>
    </thead>
    <tbody>
    <!-- 数据将插入到这里 -->
    </tbody>
</table>
</body>
</html>

可以修改为只要表格内的数据有改变就发送异步请求,来达到不刷新页面的情况下刷新数据

登录时判断

后台

@RequestMapping("/a3")
    @ResponseBody
    public String a3(String username,String password) {
        System.out.println(username);
        System.out.println(password);
        
        //假设admin和123456是从数据库取出的数据

        String msg = null;
        if (username != null) {
            if("admin".equals(username)) {
                msg = "OK";
            } else {
                msg = "用户名错误";
            }
        }

        if (password != null) {
            if("123456".equals(password)) {
                msg = "OK";
            } else {
                msg = "密码错误";
            }
        }
        return msg;
    }

前端

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录页面</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>

    <script>
        function checkUsername(){
            $.post({
                url:'http://localhost:8080/a3',
                data:{"username" : $('#username').val()},
                success:function(data){
                    console.log(data);
                    if(data.toString() === "OK"){

                    }
                    $("#usermsg").html(data);
                }
            })
        }

        function checkPassword(){
            $.post({
                url:'http://localhost:8080/a3',
                data:{"password" : $('#password').val()},
                success:function(data){
                    if(data.toString() === "OK"){

                    }
                    $("#passwordmsg").html(data);
                }
            })
        }

    </script>


</head>
<body>

<p>
    用户名:<input type="text" id="username" onblur="checkUsername()">
    <span id="usermsg"></span>
</p>

<p>
    密码:<input type="password" id="password" onblur="checkPassword()">
    <span id="passwordmsg"></span>
</p>


</body>
</html>

拦截器

拦截器是AOP思想的重要应用

拦截器实现

public class MyInterceptor implements HandlerInterceptor {

    //return true 执行下一个拦截器,放行
    //return false 不执行下个拦截器,
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("===============处理前================");
        return true;
    }


    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("===============处理后================");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("===============清理================");
    }
}

配置拦截器

    <!--拦截器配置    -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.dong.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

如果return false;则会卡在那

利用拦截器实验登录判断验证

不登录就进不了首页

文件上传

导包

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>

页面

<form action="/upload" enctype="multipart/form-data" method="post">
    <input type="file" name="file" />
    <input type="submit" value="提交" />
</form>

配置文件

    <!--文件上传配置-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--－请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
        <property name="defaultEncoding" value="utf-8"/>
        <!-- －上传文件大小上限，单位为字节（10485760=10M）-->
        <property name="maxUploadSize" value="10485760"/>
        <property name="maxInMemorySize" value="40960"/>
    </bean>

后台

    @RequestMapping("/upload")
    @ResponseBody
    public String upload(MultipartFile file) {
        System.out.println("开始上传");
        System.out.println("文件名: " + file.getOriginalFilename());
        System.out.println("文件是否为空: " + file.isEmpty());
        System.out.println("文件大小: " + file.getSize() + "字节");

        if (file.isEmpty()) {
            return "文件为空";
        }

        try {
            // 获取上传文件的文件名
            String fileName = file.getOriginalFilename();
            // 定义文件存储路径（可以根据需要调整）
            String uploadDir = "C:\\Users\\dong\\Desktop\\upload\\";
            System.out.println("上传位置: " + uploadDir);


            // 创建文件对象，并保存上传的文件到指定位置
            File destFile = new File(uploadDir + fileName);
            file.transferTo(destFile); // 将文件内容写入目标文件

            return "文件上传成功";
        } catch (IOException e) {
            e.printStackTrace();
            return "Error";
        }
    }

posted @ 2025-03-24 21:15 -殇情- 阅读(18) 评论(0) 收藏举报

刷新页面返回顶部

dongjiancheng

SpringMVC

SpringMVC

配置模版

MVC

中心控制器

第一个HelloSpringMVC程序

SpringMVC原理

使用注解开发

URL传参

普通

RestFul

指定提交方式

使用注解指定提交方式

URL传递的参数与方法参数名不一致问题

传递的是一个对象

重定向和转发

没有视图解析器

有视图解析器

乱码问题

JSON

普通json

json乱码问题

集合json

时间json

FastJson

Ajax技术

刷新表格

登录时判断

拦截器

利用拦截器实验登录判断验证

文件上传

公告