SpringMVC - 简讲

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量185 收藏
点赞数
分类专栏： java 文章标签： mvc java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Messchao/article/details/124854994
版权

SpringMVC

简介

SpringMVC概述

  • SpringMVC是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品，已经融合在Spring Web Flow中
  • SpringMVC已经成为目前最主流的MVC框架之一，并且随着Spring3.0的发布，全面超越Stuts2,成为最优秀的MVC框架。他通过一套注解，让一个简单的Java类成为处理请求的控制器，而无需实现任何接口。同时它是支持RESTful编程风格的请求

在这里插入图片描述

SpringMVC开发步骤

  • 需求：客户端发送请求，服务器端接受请求，执行逻辑并进行视图跳转
  1. 导入SpringMVC相关坐标
  2. 配置SpringMVC核心控制器DispathcerServlet
  3. 创建Controller类和视图页面
  4. 使用注解配置Controller类中业务方法的映射地址
  5. 配置SpringMVC核心文件Spring-mvc.xml文件（配置组件扫描）
  6. 客户端发送请求测试

  • 导入坐标

    • <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.12.RELEASE</version>
</dependency>

  • 配置核心控制器

    • <!--    配置SpringMVC的前端控制器-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

  • 创建Controller类和视图页面

    • @Controller
public class UserController {
    @RequestMapping("/quick")
    public String save(){
        System.out.println("Controller running.....");
        return "success.jsp";
    }
}

  • 配置SpringMVC核心文件

    • <!--    Controller组件扫描-->
    <context:component-scan base-package="com.ytzl.controller"/>

知识要点

在这里插入图片描述

SpringMVC组件解析

SpringMVC的执行流程

在这里插入图片描述

  1. 用户发送请求至前端控制器DispatcherServlet
  2. DispatcherServlet收到请求调用HandlerMapping处理器映射器
  3. 处理器映射器找到具体的处理器（可以根据xml配置、注解进行查找），生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet
  4. DispatcherServlet调动HandlerAdapter处理器适配器
  5. HandlerAdapter经过适配调用具体的处理器（Controller，也叫后端控制器）
  6. Controller执行完成返回ModelAndView
  7. HandlerAdapter将controller执行结果ModelAdnView返回给DispatcherServlet
  8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器
  9. ViewReslover解析后返回具体View
  10. DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户

SpringMVC注解解析

注解说明
@RequestMapping用户建立请求URL和处理请求方法之间的对应关系
位置
类上请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录
方法上请求URL的第二级访问目录，与类上的使用@RequestMapping标注的一级目录一起组成访问虚拟目录
//请求地址 https://lcoalhost:8080/类上的/方法上的
属性
value用于指定请求的URL，他和path属性的作用是一样的
method用于指定请求的方式
params用于指定限制请求参数的条件，它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
例如
params={“accountName”}表示请求参数必须有accountName
params={“money!100”}表示请求参数中money不能是100
@ResponseBody告诉MVC框架 不进行视图跳转 直接进行数据回响

mvc命名空间引入

在这里插入图片描述

SpringMVCd的xml配置解析

<!--    Controller组件扫描-->
    <context:component-scan base-package="com.ytzl.controller"/>
<!--配置内部资源视图解析器-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        /jsp/success.jsp-->
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

知识要点

  • SpringMVC的相关组件
    • 前端控制器：DispatcherServlet
    • 处理器映射器：HandlerMapping
    • 处理器适配器：HandlerAdapter
    • 处理器：Handler
    • 视图解析器：View Resolver
    • 视图：View
  • SpringMVC的注解和配置
    • 请求映射注解：@RequestMapping
    • 视图解析器配置：
      • REDIRECT_URL_PREFIX=“redirect”
      • FORWARD_URL_PREFIX=“forward”
      • prefix=“”
      • suffix=“”

SpringMVC的数据响应

SpringMVC的数据响应方式

  1. 页面跳转
    • 直接返回字符串
    • 通过ModelAndView对象返回
  2. 会写数据
    • 直接返回字符串
    • 返回对象或集合

返回字符串形式

  • 直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转。

在这里插入图片描述

返回ModelAndView对象

形式一：
@RequestMapping("/quick1")
public ModelAndView save1(){
    /**
     *  Mode：模型  作用封装数据
     *  View：视图  作用展示数据
     * */
    ModelAndView modelAndView = new ModelAndView();
    //设置视图名称
    modelAndView.setViewName("success");
    //设置模型数据
    modelAndView.addObject("oLike","凌乱的房间里头还留着你的香味");
    return modelAndView;
}

@RequestMapping("/quick2")
public ModelAndView save2(ModelAndView modelAndView ){
        /**
         *  Mode：模型  作用封装数据
         *  View：视图  作用展示数据
         * */
        //设置视图名称
        modelAndView.setViewName("success");
        //设置模型数据
        modelAndView.addObject("oLike","凌乱的房间里头还留着你的香味");
        return modelAndView;
}

/**
常用
*/
@RequestMapping("/quick3")
public String save3(Model model){
    model.addAttribute("oLike","凌乱的房间里头还留着你的香味");
    return "success";
}

<h1>放过我吧... ${oLike}</h1>
形式二：
@RequestMapping("/quick4")
public String save4(HttpServletRequest request){
    request.setAttribute("oLike","看到你和你的墙说话，我的心都碎了");
    return "success";
}

回写数据

直接返回字符串

  • Web基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用response.getWriter().print(“hello world”)即可，那么在Controller中想直接返回字符串该怎么做？

    1. 通过SpringMVC框架注入的response对象，使用response.getWriter().print(“”)回写数据，此时不需要视图跳转，业务方法返回值为void。

      • @RequestMapping("/quick5")
public void save5(HttpServletResponse response) throws IOException {
    response.setContentType("text/html;charset=utf-8");
    response.getWriter().print("不爱我就拉倒");
}

    2. 将需要回写的字符串直接返回，但此时需要通过 @ResponseBody注解告诉MVC框架，方法的字符串不是跳转是直接在http响应体中返回

      • @RequestMapping("/quick6")
@ResponseBody
public String save6(HttpServletResponse response){
    response.setContentType("text/html;charset=utf-8");
    return "love baby~";
}
返回json格式字符串
  • /**
 * 回写数据
 *      返回json格式数据
 * */
@RequestMapping("/json1")
@ResponseBody
public String json1(){
    return "{\"username\":\"yang\",\"age\":\"19\"}";
}

  • 导如maven坐标

  • <!--导入json格式转换工具-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.0</version>
</dependency>

  • /**
 * 回写数据
 *      返回json格式数据
 * */
@RequestMapping("/json2")
@ResponseBody
public String json2() throws JsonProcessingException {
    User user = new User();
    user.setName("yang");
    user.setAge(19);
    System.out.println(user.toString());
    //使用json的转换工具将对象转换成json格式字符串在返回
    ObjectMapper objectMapper = new ObjectMapper();
    String json = objectMapper.writeValueAsString(user);
    System.out.println(json);
    return json;
}
返回对象或集合数据，自动转成json格式
/**
 * 回写数据
 *      返回对象或集合数据
 * */
@RequestMapping("/objectOrListToJson")
@ResponseBody
//期望SpringMVC自动将User转换成json格式的字符串
public User objectOrListToJson() throws JsonProcessingException {
    User user = new User("ListOrObject",20);
    return user;
}
处理器适配器：
<!--    配置处理器映射器 返回对象或集合返回json格式字符串-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>
注释版返回对象或集合转换为json格式⭐

  • 在方法上添加 @ResponseBody就可以返回json格式的字符串，但是这样配置比较麻烦，配置的代码比较多，因此我们可以使用mvc的注解驱动代替上述配置

  • <!--mvc的注解驱动-->
<mvc:annotation-driven/>

  • 在SpringMVC的各个组件中，处理映射器、处理器适配器、视图解析器称为SpringMVC的三大组件。

  • 使用mvc:annorarion-driven自动加载RequestMappingHandlerMapping(处理映射器)和RequestMappingHandlerAdapter(处理适配器)，可用在Spring-xml.xml配置文件中使用mvc:annotation-driven替代注解处理器和适配器的配置。同时使用mvc:annotation-driven默认底层就会集成jackson进行对象或集合的json格式字符转换。

  • 可以替代处理器适配器的配置

知识要点

  • MVC的数据响应方式
    1. 页面跳转
      • 直接返回字符串
      • 通过ModelAndView对象返回
    2. 回写数据
      • 直接返回字符串
      • 返回对象或集合

SpringMVC获得请求数据

  • 客户端请求参数的格式是：name=value&name=value… …

  • 服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数

    • 基本类型参数
    • POJO类型参数
    • 数组类型参数
    • 集合类型参数

获得基本类型参数

  • Controller的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配

  • /**
 * 获取数据
 *      获得基本类型参数
 * */
@RequestMapping("/request1")
@ResponseBody
public void request1(String name,Integer age){
    System.out.println(name);
    System.out.println(age);
}

  • http://localhost:8080/dataRequest/request1?name="葛霄"&age=18

获得POJO类型参数

  • Controller中的业务方法的POJO参数的属性名与请求参数的name一致，参数值会自动映射匹配

  • /**
 * 获取数据
 *      获得POJO类型参数
 * */
@RequestMapping("/POJOData")
@ResponseBody
public void POJO(User user){
    System.out.println(user);
}

  • http://localhost:8080/dataRequest/request1?name="葛霄"&age=18

获得数组类型参数

  • Controller中的业务方法数据名称与请求参数的name一致，参数值会自动映射匹配

  • /**
 * 获取数据
 *      获得'数组'类型参数
 * */
@RequestMapping("/arrayData")
@ResponseBody
public void Array(String[] loves){
    System.out.println(Arrays.asList(loves));
}

  • http://localhost:8080/dataRequest/arrayData?loves="葛霄" loves="尚琪奇"

获得集合类型参数

List

  • 获得集合参数时，要将集合参数包装到一个POJO中才可以

  • /**
 * 获取数据
 *      获得'集合List'类型参数
 * */
@RequestMapping("/listData")
@ResponseBody
public void List(VO vo){
    System.out.println(vo);
}

  • List集合实体类

  • @Getter
@Setter
@ToString
public class VO {
    private List<User> userList;
}

  • jsp测试网页

  • <form action="${pageContext.request.contextPath}/dataRequest/listData" method="post">
    <%--表明是第一个User对象的name age--%>
        <input type="text" name="userList[0].name"><br>
        <input type="text" name="userList[0].age"><br>
        <input type="text" name="userList[1].name"><br>
        <input type="text" name="userList[1].age"><br>
        <input type="submit" value="提交">
</form>

  • 在这里插入图片描述

ajax

  • 当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接受集合数据而无需使用POJO进行包装。

  • /**
 * 获取数据
 *      获得'集合List'类型参数
 *      使用ajax
 * */
@RequestMapping("/listAjaxData")
@ResponseBody
public void listAjax(@RequestBody List<User> userList){
    System.out.println(userList);
}

  • ajax传递跳转

  • <script src="${pageContext.request.contextPath}/js/jquery-3.3.1.min.js"></script>
<script>
    console.log("${pageContext.request.contextPath}/js/jquery-3.3.1.min.js")
    var userList = new Array();
    userList.push({name:"葛霄",age:18});
    userList.push({name:"葛霄",age:19});

    $.ajax({
        type:"POST",
        url:"${pageContext.request.contextPath}/dataRequest/listAjaxData",
        data:JSON.stringify(userList),
        contentType:"application/json;charset:utf-8"
    })
</script>

  • 开放资源的访问-静态资源过滤 mvc.xml

  • <!--开放资源的访问-静态资源过滤-->
    <mvc:resources mapping="/js/**" location="/js/"/>

静态资源访问的开启⭐

<mvc:default-servlet-handler/>

请求数据中文乱码问题⭐

  • 当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤

  • WEB.xml

  • <!--配置全局过滤的filter-->
<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>

参数绑定注解@requestParam⭐

  • 当请求的参数名称与Controller的业务方法参数名称不一致时，就需要 @RequestParam注解显示的绑定

  • 注解@RequestParam还有如下参数可以使用：

    • 参数说明
      value与请求参数名称
      required此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
      defaultValue当没有指定请求参数时，则使用指定的默认值赋值
  • /**
 * 获取数据
 *      参数绑定注解
 *      value
 *          与请求参数名称
 *      required
 *          此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
 *      defaultValue
 *          当没有指定请求参数时，则使用指定的默认值赋值
 * */
@RequestMapping("/basicDataPlus")
@ResponseBody
public void basicDataPlus(@RequestParam(value = "userName",required = false,defaultValue = "藏在心底的喜欢") String name){
    System.out.println(name);
}

获得Restful风格的参数

  • Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。

  • 主要用于客户端和服务端交互类的软件，基于这个风格设计的软件可以更简介，更有层次，更易于实现缓存机制等

  • Restful风格的请求是使用==“url+请求方式”==表示一次请求目的地，HTTP协议里面四个表示操作方式的动词如下：

    • 参数说明
      GET用于获取资源
      POST用于新建资源
      PUT用于更新资源
      DELETE用于删除资源
      例如：
      /user/1 GET:得到id=1的user
      /user/1 DELETE:删除id=1的user
      /user/1 PUT:更新id=1的user
      /user POST:新增user

  • 上述url地址/user/1中的1就是要获得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。

  • 地址/user/1可以写成/user/{id}，占位符{id}对应的就是1的值。

  • 在业务方法中我们可以使用 @PathVariable注解进行占位符的匹配获取工作

  • /**
 * 获取数据
 *      Restful风格的参数
 *  localhost:8080/dataRequest/basicRestfulData/葛霄
 * */
@RequestMapping("/basicRestfulData/{username}")
@ResponseBody
public void basicRestfulData(@PathVariable(value = "username") String name){
    System.out.println(name);
}

自定义类型转换器

  • SpringMVC默认已经提供了一些常用的类型转换器，例如客户端提交的字符转换成int型进行参数设置

  • 但是，不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器

  • 自定义类型转换器的开发步骤

    1. 定义转换器类实现Converter接口

      • public class DateConverter implements Converter<String,Date> {
    @Override
    public Date convert(String dateStr) {
        //将日期字符串转换成日期对象返回
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd|");
        Date date = null;
        try {
            date = format.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

    2. 在配置文件中声明转换器

      • mvc.xml

      • <!--声明转换器-->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.ytzl.converter.DateConverter"/>
            </list>
        </property>
    </bean>

    3. 在<annotation-driven>中引用转换器

      • mvc.xml

      • <mvc:annotation-driven conversion-service="conversionService"/>

获得SpringMVC相关API

  • SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下

    • HttpServletRequest
    • HttpServletResponse
    • HttpSession
  • /**
 * 获得SpringMVC相关API
 *      HttpServletRequest
 *      HttpServletResponse
 *      HttpSession
 * */
@RequestMapping("/getSpringMvcApi")
@ResponseBody
public void getSpringMvcApi(HttpServletRequest servletRequest, HttpServletResponse servletResponse, HttpSession session){
    System.out.println(servletRequest);
    System.out.println(servletResponse);
    System.out.println(session);
}

获得请求头

  • @RequestHeader

  • 使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)，

  • @RequestHeader注解的属性如下：

    • 属性说明
      value请求头的名称
      required是否必须携带此请求头
    • /**
 * 获得请求头
 *      @RequestHeader
 * */
@RequestMapping("/getRequestHeader")
@ResponseBody
public void getRequestHeader(@RequestHeader(value = "User-Agent",required = false) String user_agent){
    System.out.println(user_agent);
}

  • @CookieValue

  • 使用 @CookieValue可以获得指定的Cookie的值

  • @CookieValue注解的属性如下：

    • 属性说明
      value指定cookie的名称
      required是否必须携带此cookie
    • /**
 * 获得Cookie的值
 *      @CookieValue
 * */
@RequestMapping("/getCookie")
@ResponseBody
public void getCookie(@CookieValue(value = "JSESSIONID",required = false) String jsessionid){
    System.out.println(jsessionid);
}

文件上传

文件上传客户端三要素

  • 表单项type=“file”

    • 文件<input type="file" name="upload"><br>

  • 表单的提交方式是post

    • <form method="post">

  • 表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”

    • <form enctype="multipart/form-data">

文件上传原理

  • 当form表单修改为多部分表单时，request.getParameter()将失效
  • enctype=“application/x-www-form-urlencoded”时，form表单的正文内容是：
    • key=value&key=value&key=value
  • 当form表单的enctype取值为Mutilpart/form-data时，请求正文内容就变成多部分形式。

单文件上传步骤

  1. 导入fileupload和io坐标

    • <!--        导入fileupload和io坐标-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>

  2. 配置文件上传解析器

    • mvc.xmls

    • <!--配置文件上传解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--上传文件的编码类型-->
        <property name="defaultEncoding" value="UTF-8"/>
        <!--上传文件总大小-->
        <property name="maxUploadSize" value="500000"/>
    </bean>

  3. 编写文件上传代码

    • <form action="${pageContext.request.contextPath}/fileUpload/oneFileUpload" method="post" enctype="multipart/form-data">
  名称<input type="text" name="username"><br>
  文件<input type="file" name="upload"><br>
  <input type="submit" value="提交">
</form>

    • /**
 * 文件上传
 *      单文件上传
 * */
@RequestMapping("/oneFileUpload")
@ResponseBody
public void oneFileUpload(String username, MultipartFile upload){
    System.out.println(username);
        //获得上传文件的名称
    String originalFilename = upload.getOriginalFilename();
    upload.transferTo(new File("F:\\uploadText\\"+originalFilename));
    System.out.println(upload);
}

多文件上传实现

  1. 导入fileupload和io坐标

  2. 配置文件上传解析器

    • <form action="${pageContext.request.contextPath}/fileUpload/FileUploads" method="post" enctype="multipart/form-data">
  名称<input type="text" name="username"><br>
  文件<input type="file" name="upload"><br>
  文件<input type="file" name="upload"><br>
  文件<input type="file" name="upload"><br>
  <input type="submit" value="提交">
</form>

  3. 编写文件上传代码

    • /**
 * 文件上传
 *      多文件上传
 * */
@RequestMapping("/FileUploads")
@ResponseBody
public void FileUploads(String username, MultipartFile[] upload) throws IOException {
    System.out.println(username);
    for (MultipartFile multipartFile : upload) {
        String originalFilename = multipartFile.getOriginalFilename();
        multipartFile.transferTo(new File("F:\\uploadText\\"+originalFilename));
    }
}

知识要点

MVC实现数据请求方式

  • 基本类型参数
  • POJO类型参数
  • 数组类型参数
  • 集合类型参数

MVC获取数据细节

  • 中文乱码问题
  • @RequestParam和@PathVariable
  • 自定义类型转换器
  • 获取Servlet相关API
  • @RequestHeader和@CookieValue
  • 文件上传

JdbcTemplate

概述

  • 它是Spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象简单的封装。Spring框架为我们提供了很多的操作模板类。
  • 例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列JmsTemplate等等。

JdbcTemplate开发步骤

  1. 导入spring-jdbc和spring-tx、mysql-connector坐标

    • <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
</dependency>

  2. 创建数据库表和实体类

    • name-money

  3. 创建JdbcTemplate对象

    • //创建数据源对象
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbctemplate");
dataSource.setUser("root");
dataSource.setPassword("123456");
//创建JdbcTemplate对象
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//设置数据源对象  知道数据库在哪
jdbcTemplate.setDataSource(dataSource);

  4. 执行数据库操作

    • //执行操作
int love = jdbcTemplate.update("insert into account values(?,?)", "yazai", 520);
if (love==1){
    System.out.println("插入成功");
}

Spring产生JdbcTemplate对象

  • 我们可以将JdbcTemplate的创建权交给Spring，将数据源DataSource的创建权也交给Spring，在Spring容器内部将数据源DataSource注入到JdbcTemplate模板对象中，配置如下

    1. applicationContext.xml

      • <!--加载jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
<!--数据源对象-->
    <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}"/>
    </bean>

<!--数据源模板对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    2. jdbc.properties

      • jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/jdbctemplate
jdbc.username=root
jdbc.password=123456

    3. test

      • /**
 * 测试Spring产生jdbcTemplate对象
 * */
@Test
public void springNewTemplate(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
    JdbcTemplate jdbcTemplate = app.getBean(JdbcTemplate.class);
    int niu = jdbcTemplate.update("insert into account values(?,?)", "niu", 666);
    if (niu==1){
        System.out.println("插入成功");
    }
}

JdbcTemplate常用操作

头部代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTemplateCRUDTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;

修

/**
 * 修改操作
 * */
@Test
public void testUpdate(){
    int niu2 = jdbcTemplate.update("update account set money=? where name=?", 1000, "niu2");
    if (niu2==1){
        System.out.println("修改成功");
    }
}

查

/**
 * 查询
 *      查询总条数
 * */
@Test
public void testQueryCount(){
    Long aLong = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
    System.out.println(aLong);
}

/**
 * 查询
 *      查询单个
 * */
@Test
public void testQueryOne(){
    Account account = jdbcTemplate.queryForObject("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), "niu2");
    System.out.println(account);
}

/**
 * 查询
 *      查询全部
 * */
@Test
public void testQueryAll(){
    List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class));
    System.out.println(accountList);
}
/**

知识要点

  1. 导入Spring-jdbc和Spring-tx坐标

  2. 创建数据库表和实体

  3. 创建JdbcTemplate对象

    • @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTemplateCRUDTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;

  4. 执行数据库操作

    • 更新操作：

      • int niu2 = jdbcTemplate.update("update account set money=? where name=?", 1000, "niu2");

    • 查询操作：

      • /*查询单个*/
Account account = jdbcTemplate.queryForObject("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), "niu2");

      • /*查询多个*/
List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class));
SpringMVC的简单入门
Mixzi的博客
04-07 1079
第一章 SpringMVC概述 1.1SpringMVC简介 SpringMVC：是基于spring的一个框架， 实际上就是spring的一个模块， 专门是做web开发的。可以理解是servlet的一个升级。它在servlet的基础上面添加了一些功能，使开发人员开发web更加方便 。 SpringMVC就是一个Spring。 Spring是容器，ioc能够管理对象，使用< bean>, @Component, @Repository, @Service, @Controller，SpringMV
SpringMVC-请求参数注入-对象类型参数注入源码探讨
wang704987562的博客
04-21 3144
接着上一篇请求参数解析，本篇分析讲请求参数解析为对象属性的源码。 demo基于springboot 与上一篇稍微不同，这里的spring版本为5.1.5。 controller @RestController @RequestMapping("/index") public class TestController { @GetMapping("/test") public St...
万字硬核解析：为什么从 MVC 到 DDD——架构的本质
wdj_yyds的博客
07-06 1475
今天要分享的是 MVC 和 DDD 的架构本质，通过由浅入深的介绍讲解和视频带着手把手操作创建工程架构。让无论是学习 MVC 的小白码农还是希望了解更多关于 DDD 内容的老白码农，都可以学习到一点自己需要的内容。
浅谈架构设计：MVC架构与DDD架构【开发实践】
qq_40656637的博客
04-07 3644
（个人理解，可能不对：将view层和controller层合并为新的controller层，作为表现层暴露接口，将model层拆分为service层和dao层）强化理解：application中的方法需要的参数类型为DTO，domain中的方法需要的参数类型为DO，而dao中的方法需要的参数类型为PO。依赖倒置的体现：应用层直接依赖于领域层的接口（如repo和gateway），通过这些接口间接依赖于下层中具体的实现类（基础设施层中的repoImpl和远程服务层中的gatewayImpl）
mvc模式的理解
dddjjj352的博客
05-12 298
mvc模式是软件工程中一种软件构架模式 分为：模型(model) 视图(view) 控制器(controller) 模型：用于封装与应用程序的业务逻辑相关的数据及对数据处理的方法。 视图：主要是监听模型层上的数据改变，实时更新页面。 控制器：接受用户的操作，主要订阅视图层事件，然后调用模型或视图全完成用户的操作 m v v m c m model v html v view
什么是MVC
热门推荐
weixin_45920385的博客
10-20 3万+
什么是MVC1、什么是MVC2、代码层面理解（1）pom依赖（2）编写一个Servlet类，用来处理用户的请求（3）编写Hello.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建hello.jsp（4）在web.xml中注册Servlet（5）配置Tomcat，并启动测试3、小结 1、什么是MVC MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范，是将业务逻辑、数据、显示分离的方法来组织代码。 MVC主要作用是降低了视图与业务逻辑间的双向
springmvc 实现Controller控制器的三种方式
编程技术分享，Java后端、Vue前端
01-07 828
为什么看到这个？因为这几天发现一个项目没有@Controller/@RequestMapping，只有@Service，但是程序居然能够进行http访问，于是百度了一下，发现还有其他方式实现controller。 先说明，只是简单说下有几种方式，不提供具体实现，因为我觉得正常新项目只会有第一种，只要知道有这几个实现方式就行。 方式一：@Controller/@RequestMapping 这也是开发人员最熟悉的了。 方式二：实现HttpRequestHandler接口 方式三：实现Controll
SpringMVC-1-概述、入门案例、请求参数的绑定、常用注解
爱学习的1024
03-14 587
# 内容： 1.三层架构与MVC 2.SpringMVC * 概述、优势 * SpringMVC的组件 3.SpringMVC入门案例 4.请求参数的绑定 5.常用的注解 ## 三层架构与MVC 1.三层架构 1.表现层(Web层) * 负责接收客户端请求，向客户端...
SpringMVC的简单讲解
但行好事 无问西东
07-30 315
什么是MVC MVC : 模型、视图、控制器 ， 是一种软件设计规范，说明不是设计模式； 本质：将业务逻辑 ， 数据 ， 显示 分离的方式来编写代码； 前后端分离； Model：数据模型，提供要展示的数据，一般我们都会把这两个分离开来 ， 数据Dao，服务层Service。 View ：负责进行数据的渲染和展示；客户端想要看到的东西 Controller：接收用户请求，交给Model处理，从M...
idea swagger生成接口文档_使用IntelliJ IDEA开发SpringMVC-自动生成RESTful文档
weixin_34513260的博客
12-23 589
简介标题不让写那么长,嗨嗨,原文主题应该为spring Boot系列之四 使用Swagger2构建RESTful API文档不知道会不会影响阅读量... 推荐越来越少了...本来系列4和系列5的文章不打算发了的,一方面是应用机会很少,另一方面也是自己当时用的时候对Spring Boot的了解还不够透彻,有点小错误.不过有粉丝评论说直接从3到了6,中间少了两篇,不成系列了,哈哈哈.那我就把错误改改...
MVC遵循的原则
碎碎念
10-13 1992
对于MVC中三者的划分并没有十分明晰的定义和界线，只是一种指导思想，让你按照model，view，controller三个方面来描述你的应用，并通过这三者的的交互，使应用功能得以正常运转。 3.1 View的职责 其中，View部分比较明确，就是负责显示。一切与显示界面无关的东西，都不应该出现在view里面。因此，view中一般不会出现复杂的判断语句，不会出现复杂的运算过程。对于PHP
SpringMVC--简介
qq_45917176的博客
02-16 126
1、什么是MVC MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分 M：Model，模型层，指工程中的JavaBean，作用是处理数据 JavaBean分为两类： 一类称为实体类Bean：专门存储业务数据的，如 Student、User 等 一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。 V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据 C：Controller，控制层，指工程中的servlet，作用
(代码)SpringMVC第1讲：HelloWorld
06-28
在本教程的第1讲中，我们将深入理解SpringMVC的基础，通过一个简单的"HelloWorld"示例来开启我们的学习之旅。 首先，我们需要在项目中引入SpringMVC的依赖。这通常通过在Maven或Gradle的配置文件中添加对应的依赖项...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 631
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1123
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 774
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 454
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 257
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 1009
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
大数据新视界 -- 大数据大厂之 Impala 性能优化：解锁大数据分析的速度密码（上）（1/30）
【青云交】荣登原力全国前三，作者周榜前四，苏州均榜首，全网领军人物前列。
11-03 1019
本文围绕 Impala 性能优化展开，阐述其对大数据分析效率和企业决策的关键意义，剖析数据规模与复杂度、查询优化等挑战。介绍数据存储（分区、压缩）和查询（索引、语句重塑）优化策略，并通过电商和金融案例展示效果。对比 Impala 与 Hive、Spark SQL 的优劣，强调 Impala 在 OLAP 查询的优势。还介绍了可视化工具对优化的助力。鼓励读者分享 Impala 使用中的优化经验，同时预告下一篇将深入探讨数据存储分区相关内容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值