SpringMVC

SpringMVC

注解收集：

-@component    组件
    -@service      service
    -@controller   contro1ler
    /*代表这个类会被Spring接管
被这个注解的类，中的所有方法，如果返回值是string，并且有具体页面可以跳转，那么就会被视图解析器解析;**/

    -@Repository   dao

    -@RequestMapping/*注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。**/


    -@PathVariable/*在Spring MVC中可以使用@PathVariable注解，让方法参数的值对应绑定到一个URl模板变量
    @RequestMapping("/add/{a}/{b}")
    public String Test(@PathVariable int a, @PathVariable int b, Model model){

    }
    **/
    -@RequestParam("username") //前端传递参数
    -@ResponseBody//它就不会走视图解析器，会直接返回一个字符串
    -@RestController//他以下只会返回字符串

JavaWeb：认真学习，老师带，入门快

SSM框架：研究官方文档，锻炼自学能力，锻炼笔记能力，锻炼项目能力

SpringMVC + Vue + SpringBoot + SpringCloud + Linux

SSM = JavaWeb做项目；

Spring：IOC和AOP

SpringMVC：SpringMVC的执行流程！SSM整合

/:只匹配所有的请求，不会去匹配jsp页面

/*:匹配所有的请求，包括jsp页面

假设:你的项目的架构，是设计好的，还是演进的?
MVC :

MVVM:

​ M V VM（ViewModel）:双向绑定

Spring:大杂烩，我们可以将SpringMVC中所有要用到的bean，注册到Spring中!

页面：{视图解析器前缀}+viewName+{视图解析器后缀}

一、SpringMVC的执行原理

1.DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

• 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
• 如上url拆分成三部分:
• http://localhost:8080服务器域名. SpringMVC部署在服务器上的web站点hello表示控制器
• 通过分析，如上url表示为:请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

2.HandlerMapping为处理器映射。DispatcherServlet调用

HandlerMapping,HandlerMapping根据请求url查找Handler。

3.HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为: hello。

4.HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

5.HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

6.Handler让具体的Controller执行。

7.Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

8.HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

9.DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

10.视图解析器将解析的逻辑视图名传给DispatcherServlet。

11.DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

12.最终视图呈现给用户。

二、配置

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">
    <!--注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件:【servLet-name】-servLet.xmL-->
        <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>
    </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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util 
       https://www.springframework.org/schema/util/spring-util.xsd">

    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

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

    <!--Handler-->
    <bean id="/hello" class="com.Aaron.controller.HelloController"/>
</beans>

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

    <!--自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
    <context:component-scan base-package="com.Aaron.controller"/>
    <!--让Spring MVC不处理静态-->
    <mvc:default-servlet-handler />
    <!--annotation-driven配置帮助我们自动完成上述两个实例的注入。-->
    <mvc:annotation-driven />

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

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

</beans>

三、注解开发SpringMVC

注解效果一样的，仅为了区分

-@component    组件
-@service      service
-@controller   contro1ler
//代表这个类会被Spring接管
//被这个注解的类，中的所有方法，如果返回值是string，并且有具体页面可以跳转，那么就会被视图解析器解析;
-@Repository   dao

RequestMapping映射路径

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的

方法都是以该地址作为父路径。

@Controller
@RequestMapping("h1")//父类
public class ControllerTest02 {
    @RequestMapping("/t2")//子类
    public String test1(Model model){
        model.addAttribute("msg","ControllerTest02");
        return "Test";
    }
}

@RequestParam前端传参

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model) {
        //前端接收参数
        System.out.println("接收到的前端参数为:" + name);
        //将结果返回给前端
        model.addAttribute("msg", name);
        //跳转视图
        return "Test";
    }
}

User传递

1. 接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
2. 假设传递的是一个对象User，匹配User对象中的字段名;如果名字一致则OK，否则，匹配不到

    @GetMapping("/t2")
    public String test2(User user){
        System.out.println(user);
        return "Test";
    }

Nodel 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解;

ModelMap 继承了LinkedMap ，除了实现了自身的一些方法，同样的继承LinkedMap 的方法和特性;

ModelAndview 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

四、RestFul风格

概念：Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层

次，更易于实现缓存等机制。

使用RestFul操作资源：可以通过不同的请求方式来实现不同的效果!如下:请求地址一样，但是功能可以不同!

• http://127.0.0.1/item/1 查询,GET
• http://127.0.0.1/item 新增,POST
• http://127.0.0.1/item 更新,PUT
• http://127.0.0.1/item/1删除,DELETE

@PathVariable注解

1、原来的写法：

@Controller
public class RestFulController {
    @RequestMapping("/add")
    public String Test(int a, int b, Model model){
        int result = a + b;
        model.addAttribute("msg","结果为："+ result);
        return "Test";
    }
}

路径：http://localhost:8080/add?a=3&b=5

2、使用注解：

在Spring MVC中可以使用@PathVariable注解，让方法参数的值对应绑定到一个URl模板变量

@Controller
public class RestFulController {
    @RequestMapping("/add/{a}/{b}")
    public String Test(@PathVariable int a, @PathVariable int b, Model model) {
        int result = a + b;
        model.addAttribute("msg", "结果为：" + result);
        return "Test";
    }
}

路径：http://Localhost:8080/add/a/b

小结：

所有的地址栏请求默认都会是HTTP GET 类型的。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

3、为什么使用？

思考：使用路径变量的好处？

• 使路径变得更加简洁、支持缓存、安全;
• 获得参数更加方便，框架会自动进行类型转换。
• 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。

五、乱码问题

1、以前的方法

过滤器filter

public class EncodingFilter implements Filter {
    public void init(FilterConfig config) throws ServletException {
    }

    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        chain.doFilter(request, response);
    }
}

web.xml记得注册！！！

    <filter>
        <filter-name>EncodingFilter</filter-name>
        <filter-class>com.Aaron.filters.EncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>EncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

2、SpringMVC过滤器

web.xml

    <!--过滤器2-->
    <filter>
        <filter-name>EncodingFilter</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>EncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

六、JSON

1、什么是JSON？

JSON（JavaScript Object Notation，JS对象标记）是一种轻量级的数据交换格式，目前使用特别广泛。

• 采用完全独立于编程语言的文本格式来存储和表示数据。
• 简洁和清晰的层次结构使得JSON成为理想的数据交换语言。
• 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在JavaScript语言中，一切都是对象。因此，任何JavaScript支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等。看

看他的要求和语法格式:

• 对象表示为键值对，数据由逗号分隔
• 花括号保存对象
• 方括号保存数组

1、将对象解析成json

<script type="text/javascript">
    //编写一个JavaScript对象
    var user = {
        name: "小菜",
        age: 3,
        sex: "男"
    }
    //json转换
    var json = JSON.stringify(user)

    console.log(user)
    console.log(json)
</script>

2、将json转换为对象

<script type="text/javascript">
    //编写一个JavaScript对象
    var user = {
        name: "小菜",
        age: 3,
        sex: "男"
    }
    //将JS对象转换为json
    var json = JSON.stringify(user);
    console.log(json);

    console.log("===================");

    //将json转换为js对象
    var obj= JSON.parse(json);
    console.log(obj);
</script>

2、使用json

1、依赖

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

2、乱码问题配置springmvc-servlet.xml

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

3、SimpleDateFormate

/**  
SimpleDateFormat函数语法：  
G 年代标志符  
y 年  
M 月 
d 日 
h 时 在上午或下午 (1~12) 
H 时 在一天中 (0~23)  
m 分  
s 秒  
S 毫秒  
E 星期 
D 一年中的第几天 
F 一月中第几个星期几 
w 一年中第几个星期 
W 一月中第几个星期 
a 上午 / 下午 标记符 
k 时 在一天中 (1~24) 
K 时 在上午或下午 (0~11)  
z 时区 */

纯Java解决

    @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        //Jackson , ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        Date date = new Date();

        SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //ObjectMapper,时间解析后的默认格式为:Timestamp，时间戳
        return mapper.writeValueAsString(SDF.format(date));
    }

Spring格式

    @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        //Jackson , ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        //不使用时间戳的形式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        mapper.setDateFormat(sdf);

        Date date = new Date();

        return mapper.writeValueAsString(date);
    }

复用工具类

JasonUtis

public class JsonUtils {
    public static String getJson(Object object, String simpleDateFormat) {
        ObjectMapper mapper = new ObjectMapper();

        //不使用时间戳的形式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat(simpleDateFormat);
        mapper.setDateFormat(sdf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

调用

    @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        Date date = new Date();

        return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
    }

七、FastJson1

fastjson三个主要的类：

• 【JsonObject代表json对象】

  • JsonObject实现了Map接口,猜想JsonObject底层操作是由Map实现的。
  • JsonObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()， isEmpty()等方法获取"键:值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

• 【JsonArray 代表json对象数组】

  • 内部是有List接口中的方法来完成操作的。

• 【Json代表JsonObject和JsonArray的转化】

  • JSON类源码分析与使用
  • 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间

1、导入依赖

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.62</version>
</dependency>

2、测试

    @RequestMapping("/j4")
    public String fastjson4() throws JsonProcessingException {
        List<User> userList = new ArrayList<User>();
        User user1 = new User("小菜1", 3, "男");
        User user2 = new User("小菜2", 3, "男");
        User user3 = new User("小菜3", 3, "男");
        User user4 = new User("小菜4", 3, "男");

        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        String string = JSON.toJSONString(userList);
        return string;
    }

CREATE TABLE books(
bookID INT(10) NOT NUll AUTO_INCREMENT COMMENT '书id',
bookName VARCHAR(100) NOT NUll COMMENT '书名',
bookCounts INT(11) NOT NUll COMMENT '数量',
detail VARCHAR(200) NOT NUll COMMENT '描述',
KEY bookID(bookID)
)ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO books(bookID,bookName,bookCounts,detail)VALUES
(1,'Java','从入门到放弃'),
(2,'MySQL','从删库到跑路'),
(3,'Linux','从进门到进牢');

八、Ajax

Ajax：异步无刷新请求

jQuery是一个库；js 的大量函数(方法)

jQuery 不是生产者，而是大自然搬运工。

jQuery Ajax本质就是XMLHttpRequest，对他进行了封装，方便调用!

js:

• 函数：闭包 （） （）
• Dom
  • id , name ,tag
  • create , remove
• Bom
  • windowo
  • document

Login.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2022/5/15
  Time: 21:20
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/js/jquery-3.6.0.js"></script>
    <script>
        function a1() {
            $.get({
                url: "${pageContext.request.contextPath}/a3",
                data: {"username": $("#username").val()},
                success: function (data) {
                    if (data.toString() === 'ok') {
                        $("#usernameInfo").css("color", "green");
                    } else {
                        $("#usernameInfo").css("color", "red");
                    }
                    $("#usernameInfo").html(data);
                }
            })
        }

        function a2() {
            $.get({
                url: "${pageContext.request.contextPath}/a3",
                data: {"password": $("#password").val()},
                success: function (data) {
                    if (data.toString() === 'ok') {
                        $("#passwordInfo").css("color", "green");
                    } else {
                        $("#passwordInfo").css("color", "red");
                    }
                    $("#passwordInfo").html(data);
                }
            })
        }
    </script>


</head>
<body>
<p>
    用户名：<input type="text" id="username" onblur="a1()">
    <span id="usernameInfo"></span>
</p>

<p>
    密码：<input type="text" id="password" onblur="a2()">
    <span id="passwordInfo"></span>
</p>

</body>
</html>

Controller.java

    @RequestMapping("/a3")
    public String a3(String username, String password) {
        String msg = "";
        if (username != null) {
            //admin在数据库中查询
            if ("admin".equals(username)) {
                msg = "ok";
            } else {
                msg = "用户名有误";
            }
        }

        if (password != null) {
            //admin在数据库中查询
            if ("12345".equals(password)) {
                msg = "ok";
            } else {
                msg = "密码有误";
            }
        }
        return msg;
    }

九、拦截器

1. 概念：SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。
2. 过滤器与拦截器的区别：拦截器是AOP思想（横切思想）的具体应用。

过滤器

• servlet规范中的一部分，任何java web工程都可以使用
• 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

• 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
• 拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的