其他分享
首页 > 其他分享> > springMVC笔记

springMVC笔记

作者：互联网

1、回顾什么是MVC

Model（模型）：

数据模型，提供要展示的数据，因此包含数据和行为，可认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

职责：

1、业务逻辑
2、保存数据的状态

View（视图）：

负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

职责：

1、显示页面

Controller（控制器）：

接收用户请求，委托给模型进行处理（状态改变）。处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

职责：

1、取得表单数据
2、调用业务逻辑
3、转向指定的页面

2、初始SpringMVC

a、为什么要学习SpringMVC呢？

1、轻量级，简单易学
2、高效，基于请求响应的MVC框架
3、与Spring兼容性好，无缝结合
4、约定大于配置
5、功能强大：ResTful、数据验证、格式化、本地化、主题等
6、简洁灵活

Spring的web框架围绕DispatcherServlet[调度servlet]设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring2.5开始，使用Java5或者以上版本的用户可采用基于注解形式进行开发，十分简洁；正因为SpringMVC好。简单、便携，易学，天生和Spring无缝集成（使用SpringIOC和AOP），使用 约定大于配置，能够进行简单的junit测试，支持Restful风格，异常处理，本地化，国际化，数据验证，类型转换，拦截器 等等

3、第一个SpringMvc程序：

a、在pom.xml中配置相应的依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.liu</groupId>
    <artifactId>SPringMVC</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springMvc-one</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>


    <dependencies>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--springMvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!--servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <!--jsp-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2.1-b03</version>
        </dependency>
        <!--jstl-->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
    
    <!--解决资源加载失败-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

b、在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">

    <!--1、配置DispatcherServlet：这个是SpringMVC的核心；请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件：【servlet-name】-servlet.xml
			也就是加载spring配置文件
		-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <!--
	注意：在springMVC中：‘/’ 和‘/*’的区别：
	‘/’：表示只匹配所有的请求，不会去匹配jsp页面。
	‘/*’：表示 匹配所有的请求，包括jsp页面。

	-->
    
</web-app>

c、在controller包中建一个HelloController

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv=new ModelAndView();
        //业务代码
        String res="HelloSpringMVC!";
        //封装对象，放在ModelAndView中
        mv.addObject("msg",res);
        //封装要跳转的视图，放在ModelANdView中
        //视图跳转
        mv.setViewName("hello");//指向 ：/WEB-INF/jsp/hello.jsp
        return mv;
    }
}

d、在resources包下建一个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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--处理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
     <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    
    <!--
	视图解析器：DispatcherServlet给他的ModelAndView
	1、获取了ModelAndView的数据
	2、解析ModelAndView的视图名字
	3、拼接视图名字，找到相应的视图：/WEB-INF/jsp/hello.jsp
	4、将数据渲染到这个视图上。
	-->
    <bean id="InternalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>


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

e、在WEB-INF下建一个jsp包，在其中建一个hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>hello</title>
</head>
<body>
<h1>我是 hello jsp</h1>
渠道的信息：${msg}
</body>
</html>

f、测试

g、注意的问题，若提示找不到（报404）：

- 99%是相关依赖没有在lib中，解决在项目中找到lib（或新建）将相关依赖添加进去，就OK了。

h、说明

- 实现接口Controller定义控制器是较老的办法
- 缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦。

4、SpringMvc执行流程

1、上图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-saj3e4f5-1640609084627)(C:\Users\24344\AppData\Roaming\Typora\typora-user-images\image-20211216154306449.png)]

2、简要分析执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BraLkdNC-1640609084628)(C:\Users\24344\AppData\Roaming\Typora\typora-user-images\image-20211216154400900.png)]

5、使用注解写第一个springMvc

a、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">

    <servlet>
        <servlet-name>springmvc1</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-coller.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc1</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

b、springmvc-coller.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
        https://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.liu.controller"/>
    <!--让springMVC不处理静态资源，ru：css、js、html、mp3-->
    <mvc:default-servlet-handler/>

    <!--
       支持mvc注解驱动
       在spring中一般采用@RequestMapping注解来完成映射关系
       要想使@RequestMapping注解生效，必须向上下文中注册
       @DefaultAnnotationHandlerMapper
       和一个AnnotationMethodHandlerAdapter实例
       这两个实例分别在类级别和方法级别处理。
       而annotation-driven配置帮助我们自动完成上述两个实例的注入
   -->
    <mvc:annotation-driven/>

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

c、在controller包下建一个NanController.java

package com.liu.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller//代表这个类会被Spring接管
//被这个注解的类中的所有方法，若返回值是String，且有具体页面可跳转，那么就会被视图解析器解析；
public class NanController {

    //真是访问地址：
    @RequestMapping("/liu")
    public String toLiu(Model model){
        //向模型中添加属性msg与值，可以在jsp页面中取出并渲染
        model.addAttribute("msg","楠小弟来了");
        //WEB-INF/jsp/liu.jsp
        return "liu";
    }
}

d、在WEB-INF下建个jsp包，在其中间隔liu.jsp

<%--
  Created by IntelliJ IDEA.
  User: 24344
  Date: 2021/12/16
  Time: 20:42
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>jkd</title>
</head>
<body>
<h1>显示内容：${msg}</h1>
</body>
</html>

e、测试

服务启动后访问：http://localhost:8080/springMvc_two_again_war_exploded/liu

6、RestFul风格：

a、概念：

RestFul就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这种风格设计的软件可以更简洁、更有层次、更易于实现缓存等机制。

b、功能：

- 资源：互联网所有的事物都可以被抽象为资源。
- 资源操作：使用POST、DELETE、PUT、GET、使用不同方法对资源进行操作。
- 分别对应：添加、删除、修改、查询。

c、传统方式操作资源：

通过不同的参数来实现不同的效果！方法单一，post和get。
- http://127.0.0.1/item/queryItem.action?id=1 【查询，GET方式】
- http://127.0.0.1/item/saveItem.action 【新增，POST方式】
- http://127.0.0.1/item/updateItem.action 【更新，POST】
- http://127.0.0.1/item/deleteItem.action?id=1 【删除，GET或POST】

d、使用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方式】

e、小测试

使用上面的例子，只需改变LiuController.java

@Controller
public class LiuController {
    @RequestMapping(value = "/hah/{a}/{b}",method = RequestMethod.GET )
//    @GetMapping("/ha/{a}/{b}")
    public String returnString(@PathVariable int a,@PathVariable int b, Model m){
        //@PathVariable：指明变量地址，此注解必须写上
        m.addAttribute("msg","即可随地可见.结果："+(a+b));
        return "nan";
    }
}

f、运行结果：

在地址栏中：http://localhost:8080/springMvc_three_again_war_exploded/hah/1/8
会跳转页面并显示信息：输出相互内容：即可随地可见.结果：9

7、重定向和转发

a、SpringMvc：结果跳转方式

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

对应的controller类：

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv=new ModelAndView();
        //业务代码
        String res="HelloSpringMVC!";
        //封装对象，放在ModelAndView中
        mv.addObject("msg",res);
        //封装要跳转的视图，放在ModelANdView中
        //视图跳转
        mv.setViewName("hello");//指向 ：/WEB-INF/jsp/hello.jsp
        return mv;
    }
}

b、通过SpringMvc实现转发和重定向-【无需视图解析器】：

测试前，需要将视图解析器注释掉

写个测试类：

@Controller
public class TestController {
    @RequestMapping("/liu/t1")
    public String test1(){
        //转发
        return "/buH.jsp";
    }

    @RequestMapping("/liu/t2")
    public String test2(){
        //转发二
        return "forward:/buH.jsp";
    }

    @RequestMapping("/liu/t3")
    public String test3(){
        //重定向
        return "redirect:/buH.jsp";
    }
}

结果：

里面的 方法一：http://localhost:8080/springMvc_three_again_war_exploded/liu/t1
	直接跳转相应的页面，但地址栏不变化
里面的 方法二：http://localhost:8080/springMvc_three_again_war_exploded/liu/t2
	直接跳转相应的页面，但地址栏不变化。
里面的 方法三：http://localhost:8080/springMvc_three_again_war_exploded/liu/t3
	回车后，跳到相应的页面，但【地址栏发生变化】

c、springMvc实现转发和重定向-【有视图解析器】：

重定向，不需要视图解析器，本质就是重新请求一个新地方，so，注意路径问题。

可重定向到另外一个请求实现。

@Controller
public class Test2Controller {

    @RequestMapping("/tes/t1")
    public String test1(){
        //转发
        return "nan";
    }

    @RequestMapping("/tes/t2")
    public String test2(){
        //重定向
        return "redirect:/buH.jsp";
        // return "redirect:hello.do";//hello.do为另一个请求
    }
}

结果:

里面的方发一：会和视图解析器 进行拼接，然后跳到目标页面，且地址栏不改变
里面的方法二：直接重定向到指定页面。

注意：

上面的例子提到的 “hello.do”，也是自定义的，和“/tes/t2”一样。

8、springMvc：数据处理

a、处理提交数据

b、数据回显到前端：

9、乱码问题：

a、编写一个表单：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>tijiao</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/f/t1" method="post">
    <input name="inp">
    <input type="submit" value="提交">
</form>
</body>
</html>

b、后代对应的类：

@Controller
public class FormController {
    @RequestMapping("/f/t1")
    public String formTest1(String inp, Model m){
        System.out.println(inp);
        m.addAttribute("msg",inp);
        return "nan";
    }
}

c、输入中文测试，发现乱码

在：http://localhost:8080/springMvc_three_again_war_exploded/formLiu.jsp
页面下的输入框：输入中文：“楠小弟”点击提交跳到：
    http://localhost:8080/springMvc_three_again_war_exploded/f/t1
显示输入的内容为乱码：æ¥ å°å¼Ÿ

d、解决乱码：在web.xml配置官方写的：

<!--2、配置SpringMVC的乱码过滤-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

e、再次输入测试：

操作和上步一样，结果显示正常。

10、SpringMVC：JSON讲解

1、什么是JSON？

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

要求和语法格式：

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

{"name","nan"}
{"age","3"}
{"sex","男"}

var obj={a:"nan",b:"hello"};这是一个对象，注意键名也可以使用引号包裹的
var json='{"a","hello",b:"nan"}';这是一个 json字符串，本质是一个字符串

2、JSON和JavaScript对象互转：

var obj=JSON.parse('{"a":"hello","b":"nan"}');
结果是：{a:'hello',b:'nan'}

var json=JSON.stringify({a:'hello',b:'nan'});
结果是：'{"a":"hello","b":""}'

3、[Jackson解析工具]Controller返回JSON数据

3.1、使用json返回时间：

4、[fastJson解析工具]

1、介绍：

fastjson.jar是阿里开发的一款专门用于Java开发的包，可方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

2、fastjson的pom依赖：

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

3、fastjson的三个主要的类：

System.out.println("*******Java对象 转 JSON字符串");
String str1=JSON.toJSONString(userList);
String str1=JSON.toJSONString(user1);

System.out.println("*******JSON字符串 转 Java对象 ");
User Juser1=JSON.parseObject(str2,User.class);

System.out.println("*******Java对象 转 JSON对象");
JSONObject jsonObject=(JSONObject)JSON.toJSON(user2);


System.out.println("******* JSON字符串 转  Java对象");
User user5=JSON.toJavaObject(jsonObject1,User.class);

11、SSM整合-【整合Mybatis】

a、数据库环境：

创建一个存放书籍数据的数据库表:

CREATE DATABASE `ssmbuild`;

USE `ssmbuild`;

DROP TABLE IF EXISTS `book`;

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',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从发现到留恋');

b、基本环境搭建pom.xml：

 <!--导入依赖-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--数据库连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>
        <!--servlet~jsp-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2.1-b03</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--mybatis-spring-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <!--spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.13</version>
        </dependency>
    </dependencies>

c、maven资源过滤：

<!--解决资源加载失败-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

d、建立基本结构和配置框架！

e、Mybatis层编写

11、SSM整合-【spring层】：

a、配置spring-dao.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--1、关联数据库配置文件-->
    <context:property-placeholder location="classpath:dataBase.properties"/>

    <!--2、连接池
        dbcp:半自动化操作，不能自动连接（spring自带的是这个）
        c3p0:自动化操作（自动化的加载配置文件，并且可自动设置到对象中）
        druid、hikari：以后会遇到
    -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!--c3p0连接池的私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!--关闭连接后不自动commit-->
        <property name="autoCommitOnClose" value="false"/>
        <!--获取连接超时时间-->
        <property name="checkoutTimeout" value="10000"/>
        <!--当获取连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>

    </bean>

    <!--3、sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>


    <!--4、配置dao接口扫描包，动态的实现了Dao接口可以注入到Spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--要扫描的dao包-->
        <property name="basePackage" value="com.liu.dao"/>
    </bean>

</beans>

b、配置spring-service.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描service包-->
    <context:component-scan base-package="com.liu.service"/>

    <!--2、将我们的所有业务类，注入到Spring，可以通过配置，或者注解实现。此处使用配置-->
    <bean id="bookServiceImpl" class="com.liu.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>

    <!--3、声明式事务配置-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--4、aop事务支持-->
</beans>

12、SSM整合-【springMvc】

a、添加web的支持

把项目变成web工程

b、配置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">
    
    <!--配置springmvc-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
             <!--此处引用的应该是整合过的总的spring配置文件-->
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <!--启动时一起加载-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--乱码过滤-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--session设置-->
    <session-config>
        <!--15分钟后session失效-->
        <session-timeout>15</session-timeout>
    </session-config>
</web-app>

c、配置spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--1、注解驱动(此处设置json乱码的地方)-->
    <mvc:annotation-driven/>
    <!--2、静态资源过滤-->
    <mvc:default-servlet-handler/>
    <!--3、扫描包-->
    <context:component-scan base-package="com.liu.controller"/>
    <!--4、视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

d、在WEB-INF下建个jsp包

13、SSM整合-【查询、增删改查功能】：

a、allBook.jsp页面：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>书籍展示</title>
    <!--BootStrap美化页面-->
    <link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>书籍列表-----显示所有书籍</small>
                </h1>
            </div>
        </div>
        <div class="row">
            <div class="col-md-4 column">
                <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">新增书籍</a>
                <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/allBook">显示全部书籍</a>
            </div>

            <div class="col-md-8 column">
                <!--查询书籍-->
                <form class="form-inline" style="float: right;text-align: center" action="${pageContext.request.contextPath}/book/queryBookByName" method="post">
                    <span style="color: red">${queryError}</span>
                    <input type="text" name="queryBookName" class="form-control"  placeholder="请输入要查询的书籍名称">
                    <input type="submit" class="btn btn-primary" value="查询">
                </form>
            </div>
        </div>
    </div>

    <div class="row clearfix">
        <div class="col-md-12 column">
            <table class="table table-hover table-striped">
                <thead>
                <tr>
                    <th>书籍编号</th>
                    <th>书籍名称</th>
                    <th>书籍数量</th>
                    <th>书籍详情</th>
                    <th>操作</th>
                </tr>
                </thead>
                <%--数据从数据库得到（跳到此页面的controller类中）--%>
                <tbody>
                <c:forEach var="book" items="${allBook}">
                    <tr>
                        <td>${book.bookID}</td>
                        <td>${book.bookName}</td>
                        <td>${book.bookCounts}</td>
                        <td>${book.detail}</td>
                        <td>
                            <a href="${pageContext.request.contextPath}/book/toUpdate?id=${book.bookID}">修改</a>
                            &nbsp;|&nbsp;
                            <a href="${pageContext.request.contextPath}/book/deleteBook/${book.bookID}">删除</a>
                        </td>
                    </tr>
                </c:forEach>
                </tbody>
            </table>
        </div>
    </div>
</div>
</body>
</html>

b、addBook.jsp添加书籍

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>增加图书</title>
    <link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>

<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>新增书籍</small>
                </h1>
            </div>
        </div>
    </div>

    <form action="${pageContext.request.contextPath}/book/addBook" method="post">
        <div class="form-group">
            <label for="bkname">书籍名称:</label>
            <input type="text" name="bookName" class="form-control" required id="bkname" placeholder="名字">
        </div>
        <div class="form-group">
            <label for="bknums">书籍数量:</label>
            <input type="text"  name="bookCounts" class="form-control" required id="bknums" placeholder="数量">
        </div>
        <div class="form-group">
            <label for="bkdes">书籍描述:</label>
            <input type="text" name="detail" class="form-control" id="bkdes" required placeholder="描述">
        </div>
        <div class="form-group">
            <input type="submit" class="form-control btn-primary" value="提交">
        </div>

    </form>

</div>
</body>
</html>

c、update Book.jsp修改页面

<%--
  Created by IntelliJ IDEA.
  User: 24344
  Date: 2021/12/19
  Time: 21:10
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>修改页面</title>
    <link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>

<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>修改书书籍</small>
                </h1>
            </div>
        </div>
    </div>

    <form action="${pageContext.request.contextPath}/book/updateBook" method="post">
        <!--书的编号隐藏-->
        <input type="hidden" name="bookID" value="${QBook.bookID}">
        <div class="form-group">
            <label for="bkname">书籍名称:</label>
            <input type="text" name="bookName" value="${QBook.bookName}" class="form-control" required id="bkname" placeholder="名字">
        </div>
        <div class="form-group">
            <label for="bknums">书籍数量:</label>
            <input type="text"  name="bookCounts" value="${QBook.bookCounts}" class="form-control" required id="bknums" placeholder="数量">
        </div>
        <div class="form-group">
            <label for="bkdes">书籍描述:</label>
            <input type="text" name="detail" value="${QBook.detail}" class="form-control" id="bkdes" required placeholder="描述">
        </div>
        <div class="form-group">
            <input type="submit" class="form-control btn-primary" value="修改">
        </div>

    </form>

</div>

</body>
</html>

d、BookController.java类

package com.liu.controller;

import com.liu.pojo.Books;
import com.liu.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
@RequestMapping("/book")
public class BookController {
    //controller调用service层
    @Autowired
    @Qualifier("bookServiceImpl")
    private BookService bookService;

    //查询全部的书籍，并且返回到一个书籍展示页面
    @RequestMapping("/allBook")
    public String bookList(Model model){
        List<Books> books = bookService.queryAllBook();
        model.addAttribute("allBook",books);
        return "allBook";
    }
    //跳转到增加书籍页面
    @RequestMapping("/toAddBook")
    public String toAddPager(){
        return "addBook";
    }

    //添加书籍的请求
    @RequestMapping("/addBook")
    public String addBook(Books books){
        System.out.println("addBook=>"+books);
        bookService.addBook(books);
        return "redirect:/book/allBook";
    }

    //跳转到修改页面
    @RequestMapping("/toUpdate")
    public String toUpdatePaper(int id,Model model){
        Books books = bookService.queryById(id);
        model.addAttribute("QBook",books);
        return "updateBook";
    }
    //修改书籍
    @RequestMapping("/updateBook")
    public String updateBook(Books books){
        int i = bookService.updateBook(books);
        return "redirect:/book/allBook";
    }

    @RequestMapping("/deleteBook/{bookId}")
    public String deleteBook(@PathVariable("bookId") int id){
        bookService.deleteBookById(id);
        return "redirect:/book/allBook";
    }

    //模糊查询
    @RequestMapping("/queryBookByName")
    public String queryBookByName(String queryBookName,Model model){
        List<Books> books = bookService.queryBookByName(queryBookName);

        if(books.size()==0){
            //当没搜到时
            model.addAttribute("queryError","未查到要搜索的书籍");
        }
        model.addAttribute("allBook",books);
        return "/allBook";
    }
}

e、dao包下的BookMapper.java接口

package com.liu.dao;

import com.liu.pojo.Books;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BookMapper {
    //增加一本书
    int addBook(Books books);

    //删除一本书
    int deleteBookById(@Param("bookId") int id);

    //更新一本书
    int updateBook(Books books);

    //查询一本书
    Books queryById(@Param("bookId") int id);

    //查询全部的书
    List<Books> queryAllBook();

    //通过书名模糊查询书籍
    List<Books>queryBookByName(@Param("bookName") String bookName);
}

f、dao包下的BookMapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.liu.dao.BookMapper">
    <insert id="addBook" parameterType="books">
        insert into ssmbuild.books( bookName, bookCounts, detail)
         VALUES(#{bookName},#{bookCounts},#{detail})
    </insert>

    <delete id="deleteBookById" parameterType="int">
        delete from ssmbuild.books where bookID=#{bookId}
    </delete>

    <update id="updateBook" parameterType="books">
        update ssmbuild.books
        set bookName=#{bookName},bookCounts=#{bookCounts} ,detail=#{detail}
        where bookID=#{bookID}
    </update>

    <select id="queryById" parameterType="int" resultType="books">
        select * from ssmbuild.books where bookID=#{bookId}
    </select>

    <select id="queryAllBook" resultType="books">
        select *from ssmbuild.books
    </select>

    <select id="queryBookByName" resultType="books">
        select * from ssmbuild.books where bookName like concat('%',#{bookName},'%')
    </select>
</mapper>

g、pojo包下的Books类

package com.liu.pojo;

public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;

    public int getBookID() {
        return bookID;
    }

    public void setBookID(int bookID) {
        this.bookID = bookID;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public int getBookCounts() {
        return bookCounts;
    }

    public void setBookCounts(int bookCounts) {
        this.bookCounts = bookCounts;
    }

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }

    public Books(int bookID, String bookName, int bookCounts, String detail) {
        this.bookID = bookID;
        this.bookName = bookName;
        this.bookCounts = bookCounts;
        this.detail = detail;
    }

    public Books() {
    }

    @Override
    public String toString() {
        return "Books{" +
                "bookID=" + bookID +
                ", bookName='" + bookName + '\'' +
                ", bookCounts=" + bookCounts +
                ", detail='" + detail + '\'' +
                '}';
    }
}

h、service包下的BookService.Java接口

package com.liu.service;

import com.liu.pojo.Books;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BookService {

    //增加一本书
    int addBook(Books books);

    //删除一本书
    int deleteBookById(int id);

    //更新一本书
    int updateBook(Books books);

    //查询一本书
    Books queryById(int id);

    //查询全部的书
    List<Books> queryAllBook();

    //通过书名模糊查询书籍
    List<Books>queryBookByName(String bookName);
}

i、BookService接口的实现类：BookServiceImpl

package com.liu.service;

import com.liu.dao.BookMapper;
import com.liu.pojo.Books;

import java.util.List;

public class BookServiceImpl implements BookService{

    //service调dao层：组合dao
    private BookMapper bookMapper;
    public void setBookMapper(BookMapper bookMapper){
        this.bookMapper=bookMapper;
    }

    @Override
    public int addBook(Books books) {
        return bookMapper.addBook(books);
    }

    @Override
    public int deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
    }

    @Override
    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
    }

    @Override
    public Books queryById(int id) {
        return bookMapper.queryById(id);
    }

    @Override
    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
    }

    @Override
    public List<Books> queryBookByName(String bookName) {
        return bookMapper.queryBookByName(bookName);
    }
}

14、简单练习使用ajax验证用户名是否存在

15、SpringMvc-拦截器

1、概述：

SpringMVC处理器拦截器类似于Servlet开发中的过滤器 Filter，用于对处理器进行预处理和后处理。开发者可自定义一些拦截器来实现特定的功能。

2、过滤器和拦截器的区别：

拦截器是AOP思想的具体应用。

3、过滤器：

4、拦截器：

5、自定义拦截器：

如何实现拦截器呢？

答：必须实现HandlerInterceptor接口。

注意：别忘记在项目工程中添加lib文件夹以及相关依赖文件。

aee/web-app_4_0.xsd"
version=“4.0”>

  <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:applicationConfig.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

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

注意：别忘记在项目工程中添加lib文件夹以及相关依赖文件。

加油，未来可期！！！

标签：return,String,springMVC,视图,liu,jsp,笔记,public
来源： https://blog.csdn.net/qq_45066822/article/details/122180205