Hello Code.
Hello Code.

【流行框架】SpringMVC

个人博客：www.hellocode.top
⭐所有文章均在上方博客首发，其他平台同步更新
本文专栏：《流行框架》
如没有JavaWEB基础，请先前往《Java Web从入门到实战》专栏学习相应知识
⚡如有问题，欢迎指正，一起学习~~

文章目录

    • 入门案例
      • 案例制作
      • SpringMVC技术架构图
    • 基本配置
      • Controller加载控制
      • 静态资源加载
      • 中文乱码处理
      • 注解驱动
    • 请求
      • 请求参数
      • 类型转换器
      • 请求映射
    • 响应
      • 无数据跳转页面
      • 带数据跳转页面
      • 纯数据返回（JSON）
      • Servlet相关接口
    • 异步调用
      • 发送异步请求
      • 返回异步请求数据
      • 跨域访问
    • 拦截器
      • 概念
      • 自定义拦截器
      • 配置与方法参数
      • 责任链模式
    • 异常处理
      • 异常处理
      • 注解异常处理
      • 项目异常处理方案
    • 实用技术
      • 文件上传下载
      • Restful
      • 表单校验
    • SSM整合
      • SSM整合
      • 注解版SSM整合

三层架构

  • 表现层：负责数据展示
  • 业务层：负责业务处理
  • 数据层：负责数据操作

【流行框架】SpringMVC_第1张图片

MVC

MVC（Model View Controller）：一种用于设计创建web应用程序表现层的模式

  • Model（模型）：数据模型，用于封装数据
  • View（视图）：页面视图，用于展示数据
    • jsp
    • html
  • Controller（控制器）：处理用户交互的调度器，用于根据用户需求处理程序逻辑
    • Servlet
    • SpringMVC

【流行框架】SpringMVC_第2张图片

入门案例

SpringMVC是一种基于Java实现MVC模型的轻量级Web框架

  • 使用简单
  • 性能突出（相比现有的框架技术）
  • 灵活性强

案例制作

  • XML版
  • XML+注解版*（主体）*
  • 纯注解版*（变形）*

基于Spring环境开发

SpringMVC版本与Spring版本同步------5.1.9

导坐标

<dependencies>
    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>javax.servlet-apiartifactId>
      <version>3.1.0version>
      <scope>providedscope>
    dependency>
    <dependency>
      <groupId>javax.servlet.jspgroupId>
      <artifactId>jsp-apiartifactId>
      <version>2.1version>
      <scope>providedscope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.1.9.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webartifactId>
      <version>5.1.9.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>5.1.9.RELEASEversion>
    dependency>
  dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.mavengroupId>
        <artifactId>tomcat7-maven-pluginartifactId>
        <version>2.1version>
        <configuration>
          <port>80port>
          <path>/path>
        configuration>
      plugin>
    plugins>
  build>

定义表现层业务处理器Controller，并配置成spring的bean（等同于Servlet）

设定具体的Controller的访问路径（等同于Servlet在web.xml中的配置），设置返回页面

@Controller
public class UserController {
    @RequestMapping("/save")
    public String save(){
        System.out.println("user mvc controller is running...");
        return "success.jsp";
    }
}

该bean的处理需要使用独立的配置文件扫描（XML版）


<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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="top.hellocode"/>
beans>

web.xml中配置SpringMVC核心控制器，用于将请求转发到对应的具体业务处理器Controller中（等同于Servlet配置）

<servlet>
    <servlet-name>DispatcherServletservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    <init-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:spring-mvc.xmlparam-value>
    init-param>
servlet>

<servlet-mapping>
    <servlet-name>DispatcherServletservlet-name>
    <url-pattern>/url-pattern>
servlet-mapping>

步骤

  • 导入坐标
  • 定义Controller类
  • 配置DispatcherServlet
  • 配置访问路径
  • 配置跳转页面

SpringMVC技术架构图

【流行框架】SpringMVC_第3张图片

  • DispatcherServlet：前端控制器，是整体流程控制的中心，由其调用其他组件处理用户的请求，有效的降低了组件间的耦合性
  • HandlerMapping：处理器映射器，负责根据用户请求找到对应具体的Handler处理器
  • Handler：处理器，业务处理的核心类，通常由开发者编写，描述具体的业务
  • View Resolver：视图解析器，将处理结果生成view视图
  • View：视图，最终产出结果，常用视图如jsp、html

【流行框架】SpringMVC_第4张图片

基本配置

Controller加载控制

  • SpringMVC的处理器对应的bean必须按照规范格式开发，为避免加入无效的bean可通过bean加载过滤器进行包含设定或排除设定，表现层bean标注通常设定为@Controller

    <context:component-scan base-package="top.hellocode">
    <context:include-filter 
             type="annotation" 
             expression="org.springframework.stereotype.Controller"/>
context:component-scan>

  • 业务层与数据层bean加载由Spring控制，参照Spring加载方式

  • 表现层bean加载由SpringMVC单独控制

    • 表现层处理器bean使用注解@Controller声明
    • bean加载控制使用包含性过滤器
    • 过滤器类型为通过注解进行过滤
    • 过滤的注解名称为Controller

静态资源加载

  • 核心控制器拦截的是所有请求，需要对静态资源请求进行放行，通过配置放行资源实现

    <mvc:resources mapping="/img/**" location="/img/"/>
<mvc:resources mapping="/js/**" location="/js/"/>

  • 使用简化格式可以放行所有普通资源调用，无需一一枚举

中文乱码处理

  • SpringMVC提供专用的中文字符过滤器，用于处理乱码问题

    CharacterEncodingFilter
    org.springframework.web.filter.CharacterEncodingFilter
    
        encoding
        UTF-8
    


    CharacterEncodingFilter
    /*

注解驱动

使用注解形式转化SpringMVC核心配置文件为配置类

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年07月17日 11:26
 */
@Configuration
@ComponentScan(value = "top.hellocode",includeFilters =
    @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
)
public class SpringMVCConfiguration implements WebMvcConfigurer {
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/img/**").addResourceLocations("/img/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
    }

    // 简化格式（和上面的二选一即可）
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

基于servlet3.0规范，自定义Servlet容器初始化配置类，加载SpringMVC核心配置类

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年07月17日 11:31
 */
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    // 加载SpringMVC的配置文件
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMVCConfiguration.class);
        return ctx;
    }

    // 映射配置
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        super.onStartup(servletContext);
        CharacterEncodingFilter cef = new CharacterEncodingFilter();
        cef.setEncoding("UTF-8");
        FilterRegistration.Dynamic registration = servletContext.addFilter("characterEncodingFilter", cef);
        registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST,DispatcherType.FORWARD,DispatcherType.INCLUDE),false,"/*");
    }
}

bean加载过滤（注解版）

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年07月17日 11:26
 */
@Configuration
@ComponentScan(value = "top.hellocode",includeFilters =
    @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
)
public class SpringMVCConfiguration implements WebMvcConfigurer {
}

静态资源加载过滤（注解版）

  • 配置类实现WebMvcConfigurer接口，覆盖addResourceHandlers方法，在其中对具体的资源进行设定

    public class SpringMVCConfiguration implements WebMvcConfigurer {
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/img/**").addResourceLocations("/img/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
    }
}

  • 或覆盖configureDefaultServletHandling方法，使用Servlet默认过滤规则

    public class SpringMVCConfiguration implements WebMvcConfigurer {
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

中文乱码处理（注解版）

在Servlet3.0规范启动服务器时做的工作通过实现ServletContainerInitializer接口，在onStartup方法中完成，包括监听器注册、过滤器注册等

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        super.onStartup(servletContext);
        CharacterEncodingFilter cef = new CharacterEncodingFilter();
        cef.setEncoding("UTF-8");
        FilterRegistration.Dynamic registration = servletContext.addFilter("characterEncodingFilter", cef);
        registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST,DispatcherType.FORWARD,DispatcherType.INCLUDE),false,"/*");
    }
}

ServletContainerInitConfig

public class ServletContainerInitConfig extends AbstractDispatcherServletInitializer {
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMVCConfig.class);
        return ctx;
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

请求

请求参数

  • SpringMVC将传递的参数封装到处理器方法的形参中，达到快速访问参数的目的
    访问URL：http://localhost/requestParam?name=hellocode

    @RequestMapping("/requestParam")
public String requestParam(String name){
    System.out.println("name="+name);
    return "page.jsp";
}

  • 请求参数类型

    • 普通类型参数
    • POJO类型参数
    • 数组类型参数
    • 集合类型参数

普通类型参数

  • 参数名与处理器方法形参名保持一致
    访问URL：http://localhost/requestParam?name=hellocode&age=14

    @RequestMapping("/requestParam")
public String requestParam(String name,String age){
    System.out.println("name="+name+",age="+age);
    return "page.jsp";
}

参数设定

  • 名称：@RequestParam

  • 类型：形参注解

  • 位置：处理器类中的方法形参前方

  • 作用：绑定请求参数与对应处理方法形参间的关系

  • 范例

    @RequestMapping("/requestParam")
public String requestParam(@RequestParam(
    							name = "userName",
    							required = true,
    							defaultValue = "hellocode") String name){
    System.out.println("name=" + name);
    return "page.jsp";
}
    • 访问路径：/requestParam/userName=hellocode

POJO类型参数

  • 当POJO中使用简单类型属性时，参数名称与POJO类属性名保持一致
    访问URL：http://localhost/requestParam?name=hellocode&age=14

    public class User{
    private String name;
    private Integer age;
}

    @RequestMapping("/requestParam")
public String requestParam(User user){
    System.out.println("name="+user.getName());
    return "page.jsp";
}

  • 当POJO类型属性与其他形参出现同名问题时，将被同时赋值
    建议使用@RequestParam注解进行区分

    @RequestMapping("/requestParam")
public String requestParam(User user, String age){
    System.out.println("user.age=" + user.getAge() + ",age=" + age);
    return "page.jsp";
}

    public class User{
    private String name;
    private Integer age;
}

    这时age既会给User中的age属性赋值，同时也会给方法的形参age赋值

复杂POJO类型参数

  • 当POJO中出现对象属性时，参数名称与对象层次结构名称保持一致
    访问URL：http://localhost/request?address.province=beijing

【流行框架】SpringMVC_第5张图片

  • 当POJO中出现集合，保存简单数据，使用多个相同名称的参数为其进行赋值
    访问URL：http://localhost/requestParam?nick=Jock1&nick=Jock2

    public class User{
    private List<String> nick;
}

    @RequestMapping("/requestParam")
public String requestParam(User user){
    System.out.println("user.nick=" + user.getNick());
    return "page.jsp";
}

  • 当POJO中出现List，保存对象数据，参数名称与对象层次结构名称保持一致，使用数组格式描述集合中对象的位置
    访问URL：http://localhost/requestParam?addresses[0].province=bj&addresses[1].province=tj

    public class User{
    private String name;
    private Integer age;
    private List<Address> addresses;
}

    public class Address{
    private String province;
    private String city;
    private String address;
}

    @RequestMapping("/requestParam")
public String requestParam(User user){
    System.out.println("user.addresses=" + user.getAddress());
    return "page.jsp";
}

  • 当POJO中出现Map，保存对象数据，参数名称与对象层次结构名称保持一致，使用映射格式描述集合中对象的位置
    访问URL：http://localhost/requestParam?addressMap['home'].province=bj&addressMap['job'].province=tj

    public class User{
    private String name;
    private Integer age;
    private Map<String,Address> addressMap;
}

    public class Address{
    private String province;
    private String city;
    private String address;
}

    @RequestMapping("/requestParam")
public String requestParam(User user){
    System.out.println("user.addressMap=" + user.getAddressMap());
    return "page.jsp";
}

数组类型参数

  • 请求参数名与处理器方法形参名保持一致，且请求参数数量>1个
    访问URL：http://localhost/requestParam?nick=Jock&nick=zahc

    @RequestMapping("/requestParam")
public String requestParam(String[] nick){
    System.out.println(nick[0] + "," + nick[1]);
    return "page.jsp";
}

集合类型参数

  • 保存简单型数据，请求参数名与处理器方法形参名保持一致，且请求参数数量>1个
    访问URL：http://localhost/requestParam?nick=Jock&nick=skaa

    @RequestMapping("/requestParam")
public String requestParam(@RequestParam("nick") List<String> nick){
    System.out.println(nick);
    return "page.jsp";
}

SpringMVC默认将List作为对象处理，赋值前先创建对象，然后将nick作为对象的属性进行处理。由于List是接口，无法创建对象，报无法找到构造方法异常；修复类型为可创建对象的ArrayList类型后，对象可以创建，但没有nick属性，因此数据为空。此时需要告知SpringMVC的处理器nick是一组数据，而不是一个单一数据。通过@RequestParam注解，将数量大于1个names参数打包成参数数组后， SpringMVC才能识别该数据格式，并判定形参类型是否为数组或集合，并按数组或集合对象的形式操作数据。

  • 集合存储引用类型数据POJO使用异步调用的形式进行，此处了解即可

类型转换器

  • SpringMVC对接收的数据进行自动类型转换，该工作通过Converter接口实现

标量转换器

方法 解释
StringToBooleanConverter String→Boolean
ObjectToStringConverter Object→String
StringToNumberConverterFactory String→Number（ Integer、 Long等）
NumberToNumberConverterFactory Number子类型之间(Integer、 Long、 Double等)
StringToCharacterConverter String→java.lang.Character
NumberToCharacterConverter Number子类型(Integer、 Long、 Double等)→java.lang.Character
CharacterToNumberFactory java.lang.Character→Number子类型(Integer、 Long、 Double等)
StringToEnumConverterFactory String→enum类型
EnumToStringConverter enum类型→String
StringToLocaleConverter String→java.util.Local
PropertiesToStringConverter java.util.Properties→String
StringToPropertiesConverter String→java.util.Properties

集合、数组相关转换器

方法 解释
ArrayToCollectionConverter 数组→集合（ List、 Set）
CollectionToArrayConverter 集合（ List、 Set） →数组
ArrayToArrayConverter 数组间
CollectionToCollectionConverter 集合间（ List、 Set）
MapToMapConverter Map间
ArrayToStringConverter 数组→String类型
StringToArrayConverter String→数组， trim后使用“,”split
ArrayToObjectConverter 数组→Object
ObjectToArrayConverter Object→单元素数组
CollectionToStringConverter 集合（ List、 Set） →String
StringToCollectionConverter String→集合（ List、 Set）， trim后使用“,”split
CollectionToObjectConverter 集合→Object
ObjectToCollectionConverter Object→单元素集合

默认转换器

方法 解释
ObjectToObjectConverter Object间
IdToEntityConverter Id→Entity
FallbackObjectToStringConverter Object→String

日期类型格式转换


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

<bean id="conversionService"
      class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    
    <property name="formatters">
        
        <set>
            
            <bean class="org.springframework.format.datetime.DateFormatter">
                
                <property name="pattern" value="yyyy-MM-dd"/>
            bean>
        set>
    property>
bean>

日期类型格式转换（注解简化版）

  • 名称： @DateTimeFormat

  • 类型： 形参注解、成员变量注解

  • 位置：形参前面 或 成员变量上方

  • 作用：为当前参数或变量指定类型转换规则

  • 范例

    public String requestParam12(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
    System.out.println("date="+date);
    return "page.jsp";
}

    @DateTimeFormat(pattern = "yyyy-MM-dd")
private Date birthday;

注意：需要在SpringMVC配置文件中加上注解驱动标签

自定义类型转换器

  • 自定义类型转换器，实现Converter接口，并制定转换前与转换后的类型

<bean id="myDateConverter" class="com.itzhuzhu.converter.MyDateConverter"/>

<bean id="conversionService"
      class="org.springframework.context.support.ConversionServiceFactoryBean">
    
    <property name="converters">
        
        <set>
            
            <ref bean="myDateConverter"/>
        set>
    property>
bean>

//自定义类型转换器，实现Converter接口，接口中指定的泛型即为最终作用的条件
//本例中的泛型填写的是String，Date，最终出现字符串转日期时，该类型转换器生效
public class MyDateConverter implements Converter<String, Date> {
    //重写接口的抽象方法，参数由泛型决定
    public Date convert(String source) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        //类型转换器无法预计使用过程中出现的异常，因此必须在类型转换器内部捕获，不允许抛出，框架无法预计此类异常如何处理
        try {
            date = df.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}


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

请求映射

  • 名称：@RequestMapping

  • 类型：方法注解

  • 位置：处理器类中的方法定义上方

  • 作用：绑定请求地址与对应处理方法间的关系

  • 范例

    @RequestMapping("/requestURL")
public String requestURL(){
    return "page.jsp";
}
    • 访问路径：/requestURL

  • 名称： @RequestMapping

  • 类型： 类注解

  • 位置：处理器类定义上方

  • 作用：为当前处理器中所有方法设定公共的访问路径前缀

  • 访问URL：http://localhost:8080/user/requestParam14

  • 如果返回的有图片，那么图片也要放在user包下

    @Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/requestParam")
    public String requestParam() {
        return "page.jsp";
        // return "/page.jsp"; 如果类上配置了RequestMapping，在返回文件前加个/也是可以访问到的
    }
}

常用属性

@RequestMapping(
    value="/requestParam15", //设定请求路径，与path属性、 value属性相同
    method = RequestMethod.GET, //设定请求方式
    params = "name", //设定请求参数条件
    headers = "content-type=text/*", //设定请求消息头条件
    consumes = "text/*", //用于指定可以接收的请求正文类型（MIME类型）
    produces = "text/*" //用于指定可以生成的响应正文类型（MIME类型）
)
public String requestParam15() {
    return "/page.jsp";
}

响应

  • 页面
    • HTML（页面）
    • JSP（页面+数据）
    • …
  • 数据
    • JSON数据
    • XML数据
    • 文本数据
  • 文件
    • 数据流

不论是页面、数据还是文件，最终传递的都是数据流

无数据跳转页面

  • 当处理器方法的返回值类型为String类型，即可通过具体的返回值设置访问的页面

    @Controller
public class UserController{
    @RequestMapping("/showPage")
    public String showPage(){
        System.out.println("user mvc controller is running ...");
        return "page.jsp";
    }
}

页面跳转方式

  • 转发（默认）

    @RequestMapping("/showPage1")
public String showPage1(){
    System.out.println("user mvc controller is running ...");
    return "forward:page.jsp";
}

  • 重定向

    @RequestMapping("/showPage2")
public String showPage2(){
    System.out.println("user mvc controller is running ...");
    return "redirect:page.jsp";
}

注意：页面访问地址中需要带/

页面访问快捷设定

  • 展示页面的保存位置通常固定，且结构相似，可以设定通用的访问路径，简化页面配置格式

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/WEB-INF/pages/" />
    <property name="suffix" value=".jsp" />
bean>

    public String showPage(){
    return "page";
}

  • 如果未设定返回值，使用void类型，则默认使用访问路径作页面地址的前缀后缀

    @RequestMapping("/showPage6")
public void showPage5(){
}

    等同于

    @RequestMapping("/showPage6")
public String showPage5(){
    return "showPage6";
}

带数据跳转页面

方式一：使用HttpServletRequest类型形参进行数据传递

@RequestMapping("/showPageAndData")
public String showPageAndData(HttpServletRequest request){
    request.setAttribute("name","hellocode");
    return "page";
}

方式二：使用Model类型形参进行数据传递

@RequestMapping("/showPageAndData")
public String showPageAndData(Model model){
    model.addAttribute("name","hellocode");
    Book book = new Book();
    book.setName("SpringMVC入门实战");
    book.setPrice(66.6D);
    model.addAttribute("book",book);
    return "page";
}

方式三：使用ModelAndView类型形参进行数据传递，将该对象作为返回值传递给调用者（推荐）

@RequestMapping("/showPageAndData")
public ModelAndView showPageAndData(ModelAndView modelAndView){
    modelAndView.addObject("name","hellocode");
    Book book = new Book();
    book.setName("SpringMVC入门实战");
    book.setPrice(66.6D);
    modelAndView.addObject("book",book);
    modelAndView.setViewName("page.jsp");		// 如果配置了快捷方式，省略前后缀
    return modelAndView;
}

方式三同样支持forward和redirect

  • String：仅封装跳转页面的基本信息，底层由ModelAndView实现
  • Model：仅封装数据
  • ModelAndView：封装数据并封装视图，包含Model和View两个对象

纯数据返回（JSON）

方式一：使用response对象完成数据返回

@RequestMapping("/showData")
public void showData(HttpServletResponse response) throws IOException{
    response.getWriter().print("message");
}

方式二：（简化格式）

@RequestMapping("/showData")
@ResponseBody
public String showData(){
    return "message";
}

返回JSON

需要导入json相应的maven坐标

方式一：基于response返回数据的简化格式，返回JSON数据

@RequestMapping("/showData")
@ResponseBody
public String showData() throws JsonProcessingException{
    ObjectMapper om = new ObjectMapper();
    Book book = new Book();
    book.setName("SpringMVC入门实战");
    book.setPrice(88.8d);
    return om.writeValueAsString(book);
}

方式二：使用SpringMVC提供的消息类型转换器将对象与集合数据自动转换为JSON数据

@RequestMapping("/showData")
@ResponseBody
public Book showData() throws JsonProcessingException{
    Book book = new Book();
    book.setName("SpringMVC入门实战");
    book.setPrice(88.8d);
    return book;
}

  • 手工添加信息类型转换器

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

    上述配置可通过SpringMVC注解驱动来简化

    <mvc:annotation-driven />

    注解驱动格式

    @Configuration
@ComponentScan("top.hellocode")
@EnableWebMvc
public class SpringMvcConfiguration{
}

Servlet相关接口

HttpServletRequest / HttpServletResponse / HttpSession

  • SpringMVC提供访问原始Servlet接口API的功能，通过形参声明即可
@RequestMapping("/servletApi")
public String servletApi(HttpServletRequest request, HttpServletResponse response, HttpSession session){
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
    request.setAttribute("name","itheima");
    System.out.println(request.getAttribute("name"));
    return "page.jsp";
}

Head数据获取

  • 名称： @RequestHeader

  • 类型： 形参注解

  • 位置：处理器类中的方法形参前方

  • 作用：绑定请求头数据与对应处理方法形参间的关系

  • 范例：

    @RequestMapping("/headApi")
public String headApi(@RequestHeader("Accept-Language") String head){
    System.out.println(head);
    return "page.jsp";
}

Cookie数据获取

  • 名称： @CookieValue

  • 类型： 形参注解

  • 位置：处理器类中的方法形参前方

  • 作用：绑定请求Cookie数据与对应处理方法形参间的关系

  • 范例：

    @RequestMapping("/cookieApi")
public String cookieApi(@CookieValue("JSESSIONID") String jsessionid){
    System.out.println(jsessionid);
    return "page.jsp";
}

Session数据获取

  • 名称： @SessionAttribute

  • 类型： 形参注解

  • 位置：处理器类中的方法形参前方

  • 作用：绑定请求Session数据与对应处理方法形参间的关系

  • 范例：

    @RequestMapping("/sessionApi")
public String sessionApi(@SessionAttribute("name") String name){
    System.out.println(name);
    return "page.jsp";
}

Session数据设置（了解）

  • 名称： @SessionAttributes

  • 类型： 类注解

  • 位置：处理器类上方

  • 作用：声明放入session范围的变量名称，适用于Model类型数据传参

  • 范例：

    @Controller
@SessionAttributes(names={"name"})
public class ServletController {
    @RequestMapping("/setSessionData2")
    public String setSessionDate2(Model model) {
        model.addAttribute("name", "Jock2");
        return "page.jsp";
    }
}

注解式参数数据封装底层原理

  • 数据的来源不同，对应的处理策略要进行区分
    • Head
    • Cookie
    • Session
  • SpringMVC使用策略模式进行处理分发
    • 顶层接口： HandlerMethodArgumentResolver
    • 实现类： ……

异步调用

发送异步请求

内容回顾

<a href="javascript:void(0);" id="testAjax">访问controllera>
<script type="text/javascript" src="/js/jquery-3.3.1.min.js">script>
<script type="text/javascript">
    $(function(){
    $("#testAjax").click(function(){ 		//为id="testAjax"的组件绑定点击事件
        $.ajax({ 							//发送异步调用
            type:"POST", 					//请求方式： POST请求
            url:"ajaxController", 			//请求参数（也就是请求内容）
            data:'ajax message', 			//请求参数（也就是请求内容）
            dataType:"text", 				//响应正文类型
            contentType:"application/text", //请求正文的MIME类型
        });
    });
});
script>

  • 名称： @RequestBody

  • 类型： 形参注解

  • 位置：处理器类中的方法形参前方

  • 作用：将异步提交数据组织成标准请求参数格式，并赋值给形参

  • 范例：

    //为id="testAjax"的组件绑定点击事件
$("#testAjax").click(function(){
	//发送异步调用
	$.ajax({
		//请求方式：POST请求
		type:"POST",
		//请求的地址
		url:"ajaxController",
		//请求参数（也就是请求内容）
		data:'ajax message',
		//响应正文类型
		dataType:"text",
		//请求正文的MIME类型
		contentType:"application/text",
	});
});

    
@RequestMapping("/ajaxController")
public String ajaxController(@RequestBody String message){
    System.out.println(message);
    return "page.jsp";
}

  • 注解添加到Pojo参数前方时，封装的异步提交数据按照Pojo的属性格式进行关系映射

    //为id="testAjaxPojo"的组件绑定点击事件
$("#testAjaxPojo").click(function(){
    $.ajax({
        type:"POST",
        url:"ajaxPojoToController",
        data:'{"name":"Jock","age":39}',
        dataType:"text",
        contentType:"application/json",
    });
});

    @RequestMapping("/ajaxPojoToController")
//如果处理参数是POJO，且页面发送的请求数据格式与POJO中的属性对应，@RequestBody注解可以自动映射对应请求数据到POJO中
//注意：POJO中的属性如果请求数据中没有，属性值为null，POJO中没有的属性如果请求数据中有，不进行映射
public String  ajaxPojoToController(@RequestBody User user){
    System.out.println("controller pojo :"+user);
    return "page.jsp";
}

  • 注解添加到集合参数前方时，封装的异步提交数据按照集合的存储结构进行关系映射

//为id="testAjaxList"的组件绑定点击事件
$("#testAjaxList").click(function(){
    $.ajax({
        type:"POST",
        url:"ajaxListToController",
        data:'[{"name":"Jock","age":39},{"name":"Jockme","age":40}]',
        dataType:"text",
        contentType:"application/json",
    });
});

@RequestMapping("/ajaxListToController")
//如果处理参数是List集合且封装了POJO，且页面发送的数据是JSON格式的对象数组，数据将自动映射到集合参数中
public String  ajaxListToController(@RequestBody List<User> userList){
    System.out.println("controller list :"+userList);
    return "page.jsp";
}

返回异步请求数据

异步请求响应（回顾）

//为id="testAjaxReturnJson"的组件绑定点击事件
$("#testAjaxReturnJson").click(function(){
    //发送异步调用
    $.ajax({
        type:"POST",
        url:"ajaxReturnJson",
        //回调函数
        success:function(data){
            //打印返回结果
            alert(data);
        }
    });
});

//使用注解@ResponseBody可以将返回的页面不进行解析，直接返回字符串，该注解可以添加到方法上方或返回值前面
@RequestMapping("/ajaxReturnString")
//    @ResponseBody
public @ResponseBody String ajaxReturnString(){
    System.out.println("controller return string ...");
    return "page.jsp";
}

方法返回值为POJO时，自动封装数据成json对象数据

@RequestMapping("/ajaxReturnJson")
@ResponseBody
//基于jackon技术，使用@ResponseBody注解可以将返回的POJO对象转成json格式数据
public User ajaxReturnJson(){
    System.out.println("controller return json pojo...");
    User user = new User();
    user.setName("Jockme");
    user.setAge(39);
    return user;
}

方法返回值为List时，自动封装数据成json对象数组数据

@RequestMapping("/ajaxReturnJsonList")
@ResponseBody
//基于jackon技术，使用@ResponseBody注解可以将返回的保存POJO对象的集合转成json数组格式数据
public List ajaxReturnJsonList(){
    System.out.println("controller return json list...");
    User user1 = new User();
    user1.setName("Tom");
    user1.setAge(3);

    User user2 = new User();
    user2.setName("Jerry");
    user2.setAge(5);

    ArrayList al = new ArrayList();
    al.add(user1);
    al.add(user2);

    return al;
}

  • 名称：@ResopnseBody（复习）

  • 类型：方法注解、返回值注解

  • 位置：处理器类中的方法前方

  • 作用：将异步提交的数据组织成标准请求参数格式，并赋值给形参

  • 范例

    //使用注解@ResponseBody可以将返回的页面不进行解析，直接返回字符串，该注解可以添加到方法上方或返回值前面
@RequestMapping("/ajaxReturnString")
//@ResponseBody
public @ResponseBody String ajaxReturnString(){
    System.out.println("controller return string ...");
    return "page.jsp";
}

跨域访问

  • 当通过域名A下的操作访问域名B下的资源时，称为跨域访问
  • 跨域访问时，会出现无法访问的现象

【流行框架】SpringMVC_第6张图片

跨域环境搭建

  • 为当前主机添加备用域名
    • 修改windows安装目录中的host文件
    • 格式：ip 域名
  • 动态刷新DNS
    • 命令：ipconfig /displaydns
    • 命令：ipconfig/flushdns

跨域访问支持

  • 名称： @CrossOrigin

  • 类型： 方法注解 、类注解

  • 位置：处理器类中的方法上方 或 类上方

  • 作用：设置当前处理器方法/处理器类中所有方法支持跨域访问

  • 范例：

@RequestMapping("/cross")
@ResponseBody
//使用@CrossOrigin开启跨域访问
//标注在处理器方法上方表示该方法支持跨域访问
//标注在处理器类上方表示该处理器类中的所有处理器方法均支持跨域访问
@CrossOrigin
public User cross(HttpServletRequest request){
    User user = new User();
    user.setName("Jockme");
    user.setAge(40);
    return user;
}

拦截器

概念

【流行框架】SpringMVC_第7张图片

  • 拦截器（Interceptor）是一种动态拦截方法调用的机制
  • 作用（增强）
    • 在指定方法调用前后执行预先设定后的代码
    • 阻止原始方法的执行
  • 核心原理：AOP思想
  • 拦截器链：多个拦截器按照一定的顺序，对原始被调用功能进行增强

【流行框架】SpringMVC_第8张图片

拦截器VS过滤器

  • 归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术

  • 拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

自定义拦截器

拦截器开发

  • 制作拦截器功能类（通知）
  • 配置拦截器的执行位置（切入点）

步骤

  • 实现HandlerInterceptor接口

    @Component //注意当前类必须受Spring容器控制
//定义拦截器类，实现HandlerInterceptor接口
public class MyInterceptor implements HandlerInterceptor {
     @Override
    // 原始方法调用前执行的内容
    // 返回值类型可以拦截控制的执行，true放行，false终止
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle..." + contentType);
        return true;
    }

    @Override
    // 原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    @Override
    // 原始方法调用完成后执行的内容
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

  • 配置拦截器

    • 配置执行位置
    • 配置拦截器执行类
    <mvc:interceptors>
    <mvx:interceptor>
    	<mvc:mapping path="/showPage" />
        <bean class="top.hellocode.interceptor.MyInterceptor" />
    mvx:interceptor>
mvc:interceptors>

    注意：配置顺序为先配置执行位置，后配置执行类

拦截器工作流程

【流行框架】SpringMVC_第9张图片

配置与方法参数

方法参数

  • HttpServletRequest：请求

  • HttpServletResponse：响应

  • handler：就是封装了Method方法，简单来说就是操作与原始方法相关的东西，就是通过这个对象去操作

  • ModelAndView：是handle运行完，返回的东西。通过这个参数可以对执行完的结果进行修正，例如如果你出现了什么问题，会让你去B页面

  • Exception：如果InterceptorController抛出异常，在这个afterCompletion方法里面可以拦截过滤，然后根据异常做处理

preHandle方法：handle运行之前要做的事，写在这个方法里面，例如做参数的格式处理、权限校验等等

postHandle方法：运行之后对里面数据进行处理。例如它返回了一个json数据，在这里面我想再加一条JSON数据，就需要在这里面做，比如如果你之前返回的是页面A，我在这里可以换成页面B，比如你之前登录的有session状态，我在这里可以清掉

afterCompletion方法：就干一件事，如果里面有异常，在这里可以根据异常对它进行处理

【流行框架】SpringMVC_第10张图片

【流行框架】SpringMVC_第11张图片

配置

【流行框架】SpringMVC_第12张图片

责任链模式

  • 当配置多个拦截器时，形成拦截器链
  • 拦截器链的运行顺序参照配置的先后顺序
  • 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
  • 当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

【流行框架】SpringMVC_第13张图片

责任链模式

  • 责任链模式是一种行为模式
  • 特征：沿着一条预先设定的任务链顺序执行，每个结点具有独立的工作任务
  • 优势:
    • 独立性:只关注当前节点的任务，对其他任务直接放行到下一节点
    • 隔离性:具备链式传递特征，无需知晓整体链路结构，只需等待请求到达后进行处理即可
    • 灵活性:可以任意修改链路结构动态新增或删减整体链路责任
    • 解耦:将动态任务与原始任务解耦
  • 弊端:
    • 链路过长时，处理效率低下
    • 可能存在节点上的循环引用现象，造成死循环，导致系统崩溃
  • 拦截器链的运行顺序
    • preHandler:与配置顺序相同，必定运行
    • postHandler:与配置顺序相反，可能不运行
    • afterCompletion:与配置顺序相反，可能不运行

异常处理

异常处理

HandlerExceptionResolver接口（异常处理器）

定义自己的异常处理器，需要实现SpringMVC提供的异常处理器接口，并且将自定义异常处理器类定义为Spring控制的bean（加注解@Component）

@Component // 配上注解Spring看到实现了这个接口就知道是异常处理器了
public class ExceptionResolver implements HandlerExceptionResolver {
    public ModelAndView resolveException(HttpServletRequest request,
                                         HttpServletResponse response,
                                         Object handler,
                                         Exception ex) {
        System.out.println("异常处理器正在执行中");
        ModelAndView modelAndView = new ModelAndView();
        //定义异常现象出现后，反馈给用户查看的信息
        modelAndView.addObject("msg","出错啦！ ");
        //定义异常现象出现后，反馈给用户查看的页面
        modelAndView.setViewName("error.jsp");
        return modelAndView;
    }
}

  • 根据异常的种类不同，进行分门别类的管理，返回不同的信息

    public class ExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request,
                                         HttpServletResponse response,
                                         Object handler,
                                         Exception ex) {
        System.out.println("my exception is running ...."+ex);
        ModelAndView modelAndView = new ModelAndView();
        
        if( ex instanceof NullPointerException){
            modelAndView.addObject("msg","空指针异常");
        }else if ( ex instanceof  ArithmeticException){
            modelAndView.addObject("msg","算数运算异常");
        }else{
            modelAndView.addObject("msg","未知的异常");
        }
        
        modelAndView.setViewName("error.jsp");
        return modelAndView;
    }
}

注解异常处理

使用注解实现异常分类管理

  • 名称：@ControllerAdvice

  • 类型：类注解

  • 位置：异常处理器类上方

  • 作用：设置当前类为异常处理器类

  • 范例

    @Component
@ControllerAdvice
public class ExceptionAdvice{
    @ExceptionHandler(NullPointerException.class)
    public void doNullException(){
        System.out.println("null exception ...");
    }
    //@ExceptionHandler(Exception.class)
    //@ResponseBody
    //public String doException(Exception ex){		// 如果需要拿到异常对象，可以加到方法形参处
    //    return "未知的异常";
    //}
}

  • 名称： @ExceptionHandler

  • 类型： 方法注解

  • 位置：异常处理器类中针对指定异常进行处理的方法上方

  • 作用：设置指定异常的处理方式

  • 范例

    @Component // 异常类只能有一个，多个的情况会都执行，会报错
@ControllerAdvice
public class ExceptionAdvice {

// 可以根据不同的异常  写多个异常方法
	@ExceptionHandler(NullPointerException.class)// 调用异常名
	@ResponseBody // 只让结果返回的是字符串类型的，否则会直接去匹配页面
		public String doOtherException(Exception ex){ // 写上参数可以拿到具体的参数
   			return "出错啦，请联系管理员！ ";
	} 
}

    说明：处理器方法可以设定多个

两种异常处理方式对比

  • 注解处理器可以拦截到入参类型转换异常
  • 非注解处理器无法拦截到入参类型转换异常

项目异常处理方案

异常分类

  • 业务异常
    • 规范的用户行为产生的异常
    • 不规范的用户行为操作产生的异常
  • 系统异常
    • 项目运行过程中可预计且无法避免的异常
  • 其他异常
    • 编程人员未预期到的异常

异常处理方案

  • 业务异常
    • 发送对应消息传递给用户，提醒规范操作
  • 系统异常
    • 发送固定消息传递给用户，安抚用户
    • 发送特定消息给运维人员，提醒维护
    • 记录日志
  • 其他异常
    • 发送固定消息传递给用户，安抚用户
    • 发送特定消息给编程人员，提醒维护
      • 纳入预期范围内
    • 记录日志

自定义异常

通过自定义异常将所有的异常现象进行分类管理，以统一的格式对外呈现异常消息

  • 异常定义格式

    public class BusinessException extends RuntimeException{
    public BusinessException(){
        super();
    }
    // 覆盖父类所有的构造方法，转调父类构造方法
}

  • 异常触发方式

    if(user.getName().trim().length() < 4){
    throw new BusinessException("用户名长度必须在4位以内，请重新输入！");
}

用户行为异常（业务异常）

//自定义异常继承RuntimeException，覆盖父类所有的构造方法
public class BusinessException extends RuntimeException {
    public BusinessException() {
    }

    public BusinessException(String message) {
        super(message);
    }

    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }

    public BusinessException(Throwable cause) {
        super(cause);
    }

    public BusinessException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

系统异常

//自定义异常继承RuntimeException，覆盖父类所有的构造方法
public class SystemException extends RuntimeException {
    public SystemException() {
    }

    public SystemException(String message) {
        super(message);
    }

    public SystemException(String message, Throwable cause) {
        super(message, cause);
    }

    public SystemException(Throwable cause) {
        super(cause);
    }

    public SystemException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

自定义异常触发类

@Controller
public class UserController {
    @RequestMapping("/save")
    @ResponseBody
    public List<User> save(@RequestBody User user) {
        System.out.println("user controller save is running ...");

        //模拟业务层发起调用产生了异常
        //        int i = 1/0;
        //        String str = null;
        //        str.length();

        //对用户的非法操作进行判定，并包装成异常对象进行处理，便于统一管理
        if(user.getName().trim().length() < 8){
            throw new BusinessException("对不起，用户名长度不满足要求，请重新输入！");
        }
        if(user.getAge() < 0){
            throw new BusinessException("对不起，年龄必须是0到100之间的数字！");
        }
        if(user.getAge() > 100){
            throw  new SystemException("服务器连接失败，请尽快检查处理！");
        }


        User u1 = new User();
        u1.setName("Tom");
        u1.setAge(3);
        User u2 = new User();
        u2.setName("Jerry");
        u2.setAge(5);
        ArrayList<User> al = new ArrayList<User>();
        al.add(u1);
        al.add(u2);

        return al;
    }
}

AJAX处理

<%@page pageEncoding="UTF-8" language="java" contentType="text/html;UTF-8" %>

访问springmvc后台controller，传递Json格式POJO

实用技术

文件上传下载

【流行框架】SpringMVC_第14张图片

MultipartResolver接口

  • MultipartResolver接口定义了文件上传过程中的相关操作，并对通用性操作进行了封装

    • MultipartResolver接口底层实现类CommonsMultipartResolver
    • CommonsMultipartResolver并未自主实现文件上传下载对应的功能，而是调用了apache的文件上传下载组件
    
<dependency>
    <groupId>commons-fileuploadgroupId>
    <artifactId>commons-fileuploadartifactId>
    <version>1.4version>
dependency>

SpringMVC配置

<mvc:annotation-driven/>

<context:component-scan base-package="top.hellocode"/>


<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    
    <property name="maxUploadSize" value="1024000000"/>
bean>

控制器

@RequestMapping(value = "/fileupload")
public void fileupload(MultipartFile file){
    // transferTo上传文件用的
    file.transferTo(new File("file.png"));
}

页面表单

<%@page pageEncoding="UTF-8" language="java" contentType="text/html;UTF-8" %>



    <%--文件上传表单的name属性值一定要与controller处理器中方法的参数对应，否则无法实现文件上传--%>
    上传LOGO：

    上传照片：

    上传任意文件：

注意：页面表单中的input的name值必须和控制器中的形参名一一对应，否则无法获取对应文件对象

服务器上传文件注意事项

  1. 文件命名问题，获取上传文件名，并解析文件名与扩展名
    file.getOriginalFilename();

  2. 文件名过长问题

  3. 文件保存路径

    ServletContext context = request.getServletContext();
String basePath = context.getRealPath("/uploads");
File file = new File(basePath + "/");
if(!file.exists()) file.mkdirs();

  4. 重名问题

    String uuid = UUID.randomUUID().toString().replace("-","").toUpperCase();

@RequestMapping(value = "/fileupload")
//参数中定义MultipartFile参数，用于接收页面提交的type=file类型的表单，要求表单名称与参数名相同
public String fileupload(MultipartFile file,MultipartFile file1,MultipartFile file2, HttpServletRequest request) throws IOException {
    System.out.println("file upload is running ..."+file);
    //        MultipartFile参数中封装了上传的文件的相关信息
    //        System.out.println(file.getSize());  文件大小
    //        System.out.println(file.getBytes().length);  文件所有的字节都在这个里面
    //        System.out.println(file.getContentType());   文件的类型
    //        System.out.println(file.getName());    file文件名
    //        System.out.println(file.getOriginalFilename());   上传的文件名
    //        System.out.println(file.isEmpty());   是否为空
    //首先判断是否是空文件，也就是存储空间占用为0的文件
    if(!file.isEmpty()){
        //如果大小在范围要求内正常处理，否则抛出自定义异常告知用户（未实现）
        //获取原始上传的文件名，可以作为当前文件的真实名称保存到数据库中备用
        String fileName = file.getOriginalFilename();
        //设置保存的路径
        String realPath = request.getServletContext().getRealPath("/images");
        //保存文件的方法，指定保存的位置和文件名即可，通常文件名使用随机生成策略产生，避免文件名冲突问题
        file.transferTo(new File(realPath,file.getOriginalFilename()));
    }
    //测试一次性上传多个文件
    if(!file1.isEmpty()){
        String fileName = file1.getOriginalFilename();
        //可以根据需要，对不同种类的文件做不同的存储路径的区分，修改对应的保存位置即可
        String realPath = request.getServletContext().getRealPath("/images");
        file1.transferTo(new File(realPath,file1.getOriginalFilename()));
    }
    if(!file2.isEmpty()){
        String fileName = file2.getOriginalFilename();
        String realPath = request.getServletContext().getRealPath("/images");
        file2.transferTo(new File(realPath,file2.getOriginalFilename()));
    }
    // 重名的问题：不使用用户上传的文件名，把上传的文件名封装成一个变量，再使用UUID重新赋一个名，这样用户的是用户的，服务器的是服务器的
     String uuid = UUID.randomUUID().toString().replace("-","").toUpperCase();
     return "page.jsp";
}

Restful

Rest

  • Rest(REpresentational State Transfer)：一种网络资源的访问风格，定义了网络资源的访问方式
  • 传统风格访问路径
    • http://localhost/user/get?id=1
    • http://localhost/deleteUser?id=1
  • Rest风格访问路径
    • http://localhost/user/1
  • Restful是按照Rest风格访问网络资源
  • 优点
    • 隐藏资源的访问行为，通过地址无法得知做的是何种操作
    • 书写简化

Rest行为约定方式

  • GET（查询） http://localhost/user/1 GET
  • POST（保存） http://localhost/user POST
  • PUT（更新） http://localhost/user PUT
  • DELETE（删除） http://localhost/user DELETE

注意：上述行为是约定方式，约定不是规范，可以打破，所以称Rest风格，而不是Rest规范

Restful开发入门

SpringMVC支持Restful

  • 请求路径访问配置发生变化
    • 控制器定义方式发生变化
    • 页面调用方式发生变化

Restful风格基本配置

//@Controller
//@ResponseBody
/*为如果要想返回的是字符串的话，
就必须在，每一个方法上面添加@ResponseBody，当@ResponseBody放在类上面时(现在的位置),
就可以省略在每一个方法上面添加@ResponseBody*/
//设置rest风格的控制器
@RestController/*可以使用这个注解替换@Controller和@ResponseBody*/
//设置公共访问路径，配合下方访问路径使用
@RequestMapping("/user")
public class UserController {

    //rest风格访问路径完整书写方式
    @RequestMapping("/user/{id}")//当类上面没有@RequestMapping("/user/")时，这个访问的是webapp里面的user目录下的success.jsp
	//@RequestMapping与参数的名称必须一样
    //使用@PathVariable注解获取路径上配置的具名变量，该配置可以使用多次，也就是说通过这个可以获取原先使用localhost/user?id=1，替换为localhost/user/1的效果一样，主要是获取地址栏的变量
    public String restLocation(@PathVariable Integer id){
        System.out.println("restful is running ....");
        return "success.jsp";
    }

    //rest风格访问路径简化书写方式，配合类注解@RequestMapping使用
    @RequestMapping("{id}")//当类上面有@RequestMapping("/user/")时，访问效果与上面的一样
	//@RequestMapping与参数的名称必须一样
	//@PathVariable：路径中的变量
    public String restLocation2(@PathVariable Integer id){
        System.out.println("restful is running ....get:"+id);//如果在浏览器地址栏输入localhost/user/100时，这里在控制台打印的是restful is running ....get:100
        return "success.jsp";
    }
}

Restful风格配置

【流行框架】SpringMVC_第15张图片

【流行框架】SpringMVC_第16张图片

【流行框架】SpringMVC_第17张图片

//@Controller
//@ResponseBody
/*为如果要想返回的是字符串的话，
就必须在，每一个方法上面添加@ResponseBody，当@ResponseBody放在类上面时(现在的位置),
就可以省略在每一个方法上面添加@ResponseBody*/
//设置rest风格的控制器
@RestController/*可以使用这个注解替换@Controller和@ResponseBody*/
//设置公共访问路径，配合下方访问路径使用
@RequestMapping("/user")
public class UserController {

    //接收GET请求配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.GET)
    //接收GET请求简化配置方式
    @GetMapping("{id}")//等同于 @RequestMapping(value = "{id}",method = RequestMethod.GET)
    public String get(@PathVariable Integer id){
        System.out.println("restful is running ....get:"+id);//地址栏输入：localhost/page.jsp，访问page.jsp，此时jsp的form表单的method是post ，在控制台返回打印的是restful is running ....post:1
        return "success.jsp";
    }

    //接收POST请求配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.POST)
    //接收POST请求简化配置方式
    @PostMapping("{id}")
    public String post(@PathVariable Integer id){
        System.out.println("restful is running ....post:"+id);
        return "success.jsp";
    }

    //接收PUT请求简化配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.PUT)
    //接收PUT请求简化配置方式
    @PutMapping("{id}")
    public String put(@PathVariable Integer id){
        System.out.println("restful is running ....put:"+id);
        return "success.jsp";
    }

    //接收DELETE请求简化配置方式
    @RequestMapping(value = "{id}",method = RequestMethod.DELETE)
    //接收DELETE请求简化配置方式
    @DeleteMapping("{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("restful is running ....delete:"+id);
        return "success.jsp";
    }
}

postman

  • 一款可以发送Restful风格请求的工具，方便开发调试，首次运行需要联网注册

【流行框架】SpringMVC_第18张图片

表单校验

表单校验分类

  • 校验位置
    • 客户端校验
    • 服务端校验
  • 校验内容与对应方式
    • 格式校验
      • 客户端：使用js技术，利用正则表达式校验
      • 服务端：使用校验框架
    • 逻辑校验
      • 客户端：使用ajax发送要校验的数据，在服务端完成逻辑校验，返回校验结果
      • 服务端：接收到完整的请求后，在执行业务操作前，完成逻辑校验

表单校验规则

  • 长度：例如用户名长度，评论字符数量
  • 非法字符：例如用户名组成
  • 数据格式：例如Email格式、IP地址格式
  • 边界值：例如转账金额上限，年龄上下限
  • 重复性：例如用户名是否重复
  • …

表单校验框架

  • JSR（Java Specification Requests）：Java 规范提案
    • 303:提供bean属性相关校验规则
  • JCP（Java Community Process）：Java社区

规范列表（简单了解）：

企业应用技术

  • Contexts and Dependency Injection for Java (Web Beans 1.0) (JSR 299)
  • Dependency Injection for Java 1.0 (JSR 330)@postConstruct, @PreDestroy
  • Bean Validation 1.0 (JSR 303)
  • Enterprise JavaBeans 3.1 (includes Interceptors 1.1) (JSR 318)
  • Java EE Connector Architecture 1.6 (JSR 322)
  • Java Persistence 2.0 (JSR 317)
  • Common Annotations for the Java Platform 1.1 (JSR 250)
  • Java Message Service API 1.1 (JSR 914)
  • Java Transaction API (JTA) 1.1 (JSR 907)
  • JavaMail 1.4 (JSR 919)

Web应用技术

  • Java Servlet 3.0 (JSR 315)

  • JavaServer Faces 2.0 (JSR 314)

  • JavaServer Pages 2.2/Expression Language 2.2 (JSR 245)

  • Standard Tag Library for JavaServer Pages (JSTL) 1.2 (JSR 52)

  • Debugging Support for Other Languages 1.0 (JSR 45)

模块化 (JSR 294)

  • Swing应用框架 (JSR 296)
  • JavaBeans Activation Framework (JAF) 1.1 (JSR 925)
  • Streaming API for XML (StAX) 1.0 (JSR 173)

管理与安全技术

  • Java Authentication Service Provider Interface for Containers (JSR 196)
  • Java Authorization Contract for Containers 1.3 (JSR 115)
  • Java EE Application Deployment 1.2 (JSR 88)
  • J2EE Management 1.1 (JSR 77)

Java SE中与Java EE有关的规范

  • JCache API (JSR 107)
  • Java Memory Model (JSR 133)
  • Concurrency Utilitie (JSR 166)
  • Java API for XML Processing (JAXP) 1.3 (JSR 206)
  • Java Database Connectivity 4.0 (JSR 221)
  • Java Management Extensions (JMX) 2.0 (JSR 255)
  • Java Portlet API (JSR 286)

Web Service技术

  • Java Date与Time API (JSR 310)
  • Java API for RESTful Web Services (JAX-RS) 1.1 (JSR 311)
  • Implementing Enterprise Web Services 1.3 (JSR 109)
  • Java API for XML-Based Web Services (JAX-WS) 2.2 (JSR 224)
  • Java Architecture for XML Binding (JAXB) 2.2 (JSR 222)
  • Web Services Metadata for the Java Platform (JSR 181)
  • Java API for XML-Based RPC (JAX-RPC) 1.1 (JSR 101)
  • Java APIs for XML Messaging 1.3 (JSR 67)
  • Java API for XML Registries (JAXR) 1.0 (JSR 93)

Hibernate框架

  • 包含一套独立的校验框架hibernate-validator
<dependency>
    <groupId>org.hibernategroupId>
    <artifactId>hibernate-validatorartifactId>
    <version>6.1.0.Finalversion>
dependency>

tomcat7：搭配hibernate-validator版本5.*.*.Final

tomcat8.5↑：搭配hibernate-validator版本6.*.*.Final

开启校验

  • 名称：@Valid、@Validated

  • 类型：形参注释

  • 位置：处理器类中的实体类类型的方法形参前方

  • 作用：设定对当前实体类类型参数进行校验

  • 范例

    @RequestMapping("/addemployee")
public String addEmployee(@Valid Employee employee){
    System.out.println(employee);
}

    注意：开启校验仅能对实体类类型参数进行，校验是对实体类类型参数中的属性进行校验

设定校验规则

  • 名称：@NotNull等

  • 类型：属性注解等

  • 位置：实体类属性上方

  • 作用：设定当前属性校验规则

  • 范例

    public class Employee{
    @NotNull(message = "姓名不能为空")
    private String name;		// 员工姓名
}

    每个校验规则所携带的参数不同，根据校验规则进行相应的调整

    具体的校验规则查看对应的校验框架进行获取

获取校验信息

@RequestMapping(value = "/addemployee")
public String addEmployee(@Valid Employee employee, Errors errors, Model model){
    System.out.println(employee);
    if(errors.hasErrors()){
        for(FieldError error : errors.getFieldErrors()){
            model.addAttribute(error.getField(),error.getDefaultMessage());
        }
        return "addemployee.jsp";
    }
    return "success.jsp";
}

通过形参Errors获取校验结果数据，通过Model接口将数据封装后传递到页面显示

<form action="/addemployee" method="post">
    员工姓名：<input type="text" name="name"><span style="color:red">${name}</span><br/>
    员工年龄：<input type="text" name="age"><span style="color:red">${age}</span><br/>
    <input type="submit" value="提交">
</form>

页面获取后台封装的校验结果信息

快速使用

  1. 编写实体类，存放表单数据。并且设置校验规则

    @Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @NotBlank(message = "姓名不能为空")
    private String name;

    @NotNull(message = "年龄不能为空")//此处不能用NotBlank,因为该注解只能校验字符串，而age是数字
    @Max(message = "年龄不能超过100",value = 100)
    @Min(message = "年龄不能小于1",value = 1)
    private Integer age;
}

  2. 编写处理器，接受表单数据，并且启用校验

    @Controller
@RequestMapping("/user")
@CrossOrigin
public class UserController {

    @RequestMapping("/reg")
    @ResponseBody
    public Map method(@Validated User user, Errors errors){//errors中存放校验失败的提示信息
        HashMap<Object, Object> map = new HashMap<>();
        HashMap<Object, Object> errorInfo = new HashMap<>();//存放字段名对应的错误提示
        //判断是否有错误信息
        if(errors.hasErrors()){
            for (FieldError e : errors.getFieldErrors()) {//errors.getFieldErrors()获取所有的错误信息
                //e.getField()表示获取属性名，e.getDefaultMessage()获取错误提示信息
                errorInfo.put(e.getField(),e.getDefaultMessage());
            }
        }

        if(errorInfo.size()==0){//没有错误数据
            map.put("status",true);
        }else{
            map.put("status",false);
            map.put("errorInfos",errorInfo);
        }

        return map;
    }
}

  3. 测试

步骤小结

  1. 方法参数上开启校验：@Valid 、 @Validated
  2. Bean的属性上设置校验规则：@NotBlank(message = “姓名不能为空”)
  3. 通过参数Errors获取错误信息
    • 获取所有错误：errors.getFieldErrors()
    • 获取错误字段：error.getField()
    • 获取错误提示：error.getDefaultMessage()
    • 将错误信息放置到model中显示给用户 -> JSP页面中${name}

实际的校验规则

  • 同一个字段有多个约束条件
  • 引用类型字段如何校验
  • 根据业务不同需要调整是否参与校验

多规则校验

同一个字段有多个约束条件，比如对于年龄的校验:

if (age !=null && age >18 && age < 60)

@NotNull(message = "请输入您的年龄")
@Max(value = 60,message = "年龄最大值不允许超过60岁")
@Min(value = 18,message = "年龄最小值不允许低于18岁")
private Integer age;//员工年龄

嵌套校验

引用类型字段如何校验，比如Employee中有address属性记录地址

  • 名称：@Valid
  • 类型：属性注解
  • 位置：实体类中的引用类型属性上方
  • 作用：设定当前应用类型属性中的属性开启校验

  1. 在address属性上添加@Valid注解，开启嵌套属性校验

    public class Employee {
    //实体类中的引用类型通过标注@Valid注解，设定开启当前引用类型字段中的属性参与校验
    @Valid
    private Address address;
    
    //添加address属性的get，set方法
}

  2. 开启嵌套校验后，被校验对象内部需要添加对应的校验规则，并添加嵌套属性的get，set方法

    //嵌套校验的实体中，对每个属性正常添加校验规则即可
public class Address {
    @NotBlank(message = "请输入省份名称")
    private String provinceName;//省份名称

    @NotBlank(message = "请输入城市名称")
    private String cityName;//城市名称

    @NotBlank(message = "请输入详细地址")
    private String detail;//详细住址

    @NotBlank(message = "请输入邮政编码")
    @Size(max = 6, min = 6, message = "邮政编码由6位组成")
    private String zipCode;//邮政编码
    
    //添加get，set方法
    
}

    @PostMapping(value = "/addemployee")
public String addEmployee(@Valid Employee employee, Errors errors, Model m) {
    //Errors对象用于封装校验结果，如果不满足校验规则，对应的校验结果封装到该对象中，包含校验的属性名和校验不通过返回的消息
    //判定Errors对象中是否存在未通过校验的字段
    if (errors.hasErrors()) {
        //获取所有未通过校验规则的信息
        List<FieldError> fieldErrors = errors.getFieldErrors();
        for (FieldError error : fieldErrors) {
            //将校验结果信息添加到Model对象中，用于页面显示，后期实际开发中无需这样设定，返回json数据即可
            //name = 姓名不能为空 -> ${name}
            m.addAttribute(error.getField(), error.getDefaultMessage());
            //address.cityName = 请输入城市名称 -> ${requestScope['address.provinceName']}
            //m.addAttribute("address.provinceName", "请输入省份名称");
        }

        //el获取对象属性值
        Address address = new Address();
        address.setProvinceName("test省份不能为空");
        //${address.provinceName}
        m.addAttribute("address", address);

        //当出现未通过校验的字段时，跳转页面到原始页面，进行数据回显
        return "addemployee.jsp";
    }
    return "success.jsp";
}

  3. 在jsp页面中获取嵌套属性中的错误信息
    ${requestScope['address.cityName']}

    <%--注意，引用类型的校验未通过信息不是通过对象进行封装的，直接使用对象名.属性名的格式作为整体属性字符串进行保存的，和使用者的属性传递方式有关，不具有通用性，仅适用于本案例--%>
省：${requestScope['address.provinceName']}
    
市：${requestScope['address.cityName']}

3种判定空校验器的区别

  • String 选择@NotBlank，底层会调用"字符串".trim()清除前后空格

  • int, double 选择@NotNull，不能使用@NotBlank

  • 数组选择@NotEmpty

表单数据 @NotNull @NotEmpty @NotBlank
String s = null; false false false
String s = “”; true false false
String s = " "; true true false
String s = “Jock”; true true true

分组校验
根据业务不同需要调整是否参与校验，比如同一个模块，新增和修改时校验规则是不一致的

  • 新增用户：新增时用户名不能为空
  • 修改用户：修改时不能修改用户名，所以不用强制用户名不能为空

解决方案：对不同种类的属性进行分组，在校验时可以指定参与校验的字段所属的组类

  1. 根据业务类型使用接口定义分组为Save, Update

    public interface Save {
}

    public interface Update {
}

  2. 在实体类Employee中为属性设置所属组，可以设置多个
    姓名不能为空只在新增时校验

    @NotEmpty(message = "姓名不能为空",groups = {Save.class})
private String name;//员工姓名

    年龄校验新增和修改都需要校验

    @NotEmpty(message = "年龄不能为空",groups = {Save.class, Update.class})
private Integer age;//员工年龄

  3. 在Controller的方法参数上开启分组校验，并指定使用哪一种分组：@Validated({Save.class})

    //新增Employee
@RequestMapping("/addemployee")
public String addEmployee(@Validated({Save.class}) Employee employee,
                             Errors errors, Model m) {
}

//更新Employee
@PostMapping(value = "/updateEmployee")
public String updateEmployee(@Validated({Update.class}) EmployeeGroup employee,
                             Errors errors, Model m) {
}

SSM整合

SSM（Spring+SpringMVC+Mybatis）

  • Spring（框架基础）
  • Mybatis（mysql+druid+pagehelper）
  • Spring整合Mybatis（junit测试业务层接口）
  • SpringMVC
    • rest风格（postman测试请求结果）
    • 数据封装json（jackson）
  • Spring整合SpringMVC
    • Controller调用Service
  • 其他
    • 表现层数据封装
    • 自定义异常

案例环境

SSM整合

Part0：项目基础结构搭建

  • 创建项目，组织项目结构，创建包
  • 创建表与实体类
  • 创建三层架构对应的模块、接口与实现类，建立关联关系
    • 数据层接口（代理自动创建实现类）
    • 业务层接口+业务层实现类
    • 表现层类

【流行框架】SpringMVC_第19张图片

package top.hellocode.service;

import com.github.pagehelper.PageInfo;
import org.springframework.transaction.annotation.Transactional;
import top.hellocode.domain.Student;

import java.util.List;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年08月11日 16:25
 */
@Transactional(readOnly = true)
public interface StudentService {
    /**
     * @Description:新增学生信息
     * @param student:
     * @return: void
     */
    @Transactional(readOnly = false)
    public void save(Student student);

    /**
     * @Description:删除学生信息
     * @param id:
     * @return: void
     */
    @Transactional(readOnly = false)
    public void delete(Integer id);

    /**
     * @Description:修改学生信息
     * @param student:
     * @return: void
     */
    @Transactional(readOnly = false)
    public void update(Student student);

    /**
     * @Description:查询单个学生信息
     * @param :
     * @return: void
     */
    public Student get(Integer id);

    /**
     * @Description:查询全部学生信息
     * @param :
     * @return: void
     */
    public PageInfo<Student> getAll(int page, int size);
}

Part1+Part2：SSM整合

  • 创建MyBatis映射文件
  • 创建Spring配置文件
    • 组件扫描
  • 整合MyBatis到Spring环境中
    • SqlSessionFactoryBean
    • 数据源（druid+jdbc.properties）
    • 映射扫描
    • 注解事务
    • 分页插件
  • 创建单元测试

配置分页插件与事务

整合junit测试业务层接口

<dependencies>
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.46version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>5.1.9.RELEASEversion>
    dependency>
    <dependency>
        <groupId>com.alibabagroupId>
        <artifactId>druidartifactId>
        <version>1.1.21version>
    dependency>
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatisartifactId>
        <version>3.5.3version>
    dependency>
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatis-springartifactId>
        <version>2.0.3version>
    dependency>
    <dependency>
        <groupId>com.github.pagehelpergroupId>
        <artifactId>pagehelperartifactId>
        <version>5.1.2version>
    dependency>


    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-webmvcartifactId>
        <version>5.1.9.RELEASEversion>
    dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.coregroupId>
        <artifactId>jackson-databindartifactId>
        <version>2.9.0version>
    dependency>

    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.1.9.RELEASEversion>
    dependency>
    <dependency>
        <groupId>javax.servletgroupId>
        <artifactId>javax.servlet-apiartifactId>
        <version>3.1.0version>
    dependency>
dependencies>


<build>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.mavengroupId>
            <artifactId>tomcat7-maven-pluginartifactId>
            <version>2.1version>
            <configuration>
                <port>80port>
                <path>/path>
            configuration>
        plugin>
    plugins>
build>



DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="top.hellocode.dao.StudentDao">
    <insert id="save" parameterType="top.hellocode.domain.Student">
        INSERT INTO student(name,age,birthday)VALUES(#{name},#{age},#{birthday})
    insert>

    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE uuid = #{id}
    delete>

    <update id="update" parameterType="top.hellocode.domain.Student">
        UPDATE student SET name=#{name},age=#{age},birthday=#{birthday} WHERE uuid=#{uuid}
    update>

    <select id="get" parameterType="int" resultType="top.hellocode.domain.Student">
        select * from student where uuid=#{id}
    select>

    <select id="getAll" resultType="top.hellocode.domain.Student">
        select * from student
    select>
mapper>


<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:tx="http://www.springframework.org/schema/tx"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">

    <context:component-scan base-package="top.hellocode">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    context:component-scan>

    <context:property-placeholder location="classpath:*.properties"/>
    
    <tx:annotation-driven transaction-manager="txManager"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    bean>

    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="top.hellocode.domain"/>
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <props>
                            <prop key="helperDialect">mysqlprop>
                            <prop key="reasonabke">trueprop>
                        props>
                    property>
                bean>
            array>
        property>
    bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="top.hellocode.dao"/>
    bean>

    
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    bean>
beans>

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.23.129/springmvc_ssm
jdbc.username=root
jdbc.password=密码

package top.hellocode.service;

import com.github.pagehelper.PageInfo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import top.hellocode.domain.Student;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年08月11日 17:14
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class StudentServiceTest {
    @Autowired
    private StudentService studentService;

    @Test
    public void getAll() {
        PageInfo<Student> all = studentService.getAll(1, 10);
        for (Student student : all.getList()) {
            System.out.println(student);
        }
    }
}

Part3：SpringMVC

  • web.xml加载SpringMVC
  • rest风格
  • 数据封装为json数据




<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

  

  
  
  <context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-value>
  context-param>

  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>

  <filter>
    <filter-name>CharacterEncodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
      <param-name>encodingparam-name>
      <param-value>UTF-8param-value>
    init-param>
  filter>

  <filter-mapping>
    <filter-name>CharacterEncodingFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>


  <servlet>
    <servlet-name>DispatcherServletservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    <init-param>
      <param-name>contextConfigLocationparam-name>
      <param-value>classpath:spring-mvc.xmlparam-value>
    init-param>
  servlet>

  <servlet-mapping>
    <servlet-name>DispatcherServletservlet-name>
    <url-pattern>/url-pattern>
  servlet-mapping>
web-app>


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

    <mvc:annotation-driven/>

    <context:component-scan base-package="top.hellocode.controller"/>
beans>

Part4：Spring整合SpringMVC

  • web.xml加载Spring环境
  • Controller调用Service
package top.hellocode.controller;

import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import top.hellocode.controller.results.Code;
import top.hellocode.controller.results.Result;
import top.hellocode.domain.Student;
import top.hellocode.service.StudentService;

import java.util.List;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年08月11日 16:25
 */
@RestController
@RequestMapping("/stu")
public class StudentController {
    @Autowired
    private StudentService studentService;

    @PostMapping
    public Result save(Student student){
        try{
            studentService.save(student);
            return new Result(Code.SAVE_OK);
        }catch (Exception e) {
            e.printStackTrace();
            return new Result(Code.SAVE_ERR);
        }
    }

    @DeleteMapping("{uuid}")
    public Result delete(@PathVariable Integer uuid){
        try{
            studentService.delete(uuid);
            return new Result(Code.DEL_OK);
        }catch (Exception e) {
            e.printStackTrace();
            return new Result(Code.DEL_ERR);
        }
    }

    @PutMapping
    public Result update(Student student){
        try{
            studentService.update(student);
            return new Result(Code.UPDATE_OK);
        }catch (Exception e){
            e.printStackTrace();
            return new Result(Code.UPDATE_ERR);
        }
    }

    @GetMapping("{uuid}")
    public Result get(@PathVariable Integer uuid){
        try{
            Student student = studentService.get(uuid);
            return new Result(Code.GET_OK,student);
        }catch (Exception e){
            e.printStackTrace();
            return new Result(Code.GET_ERR);
        }
    }

    @GetMapping("{page}/{size}")
    public Result getAll(@PathVariable Integer page, @PathVariable Integer size){
        try{
            PageInfo<Student> all = studentService.getAll(page, size);
            return new Result(Code.GET_OK,all);
        }catch (Exception e){
            e.printStackTrace();
            return new Result(Code.GET_ERR);
        }
    }
}

Part5-1：表现层数据封装

前端接收表现层返回的数据种类

  • 操作是否成功：true/false
  • 单个数据：1,100,true,…
  • 对象数据：json对象,…
  • 集合数据：json数组,…

返回数据格式设计

  • 状态
  • 数据
  • 消息

返回数据状态设计

  • 根据业务不同设计不同的状态码
    • 404
    • 500
    • 200
    • …
package top.hellocode.controller.results;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年08月12日 9:36
 */
public class Result {
    private Integer code;      //结果编码
    private Object data;    // 返回数据
    private String message;     // 消息

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Result(Integer code) {
        this.code = code;
    }

    public Result(Integer code, Object data) {
        this.code = code;
        this.data = data;
    }

    public Result(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}


package top.hellocode.controller.results;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年08月12日 9:36
 */
public class Code {
    // 成功
    public static final Integer SAVE_OK = 20011;
    public static final Integer DEL_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    // 失败
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DEL_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

Part5-2：自定义异常

  • 设定自定义异常，封装程序执行过程中出现的问题，便于表现层进行统一的异常拦截并进行处理
    • BusinessException
    • SystemException
  • 自定义异常消息返回时需要与业务正常执行的消息按照统一的格式进行处理
package top.hellocode.system.exception;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年08月12日 9:48
 */
public class BusinessException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public BusinessException() {
        super();
    }

    public BusinessException(String message,Integer code) {
        super(message);
        this.code = code;
    }

    public BusinessException(String message, Throwable cause,Integer code) {
        super(message, cause);
        this.code = code;
    }

    public BusinessException(Throwable cause,Integer code) {
        super(cause);
        this.code = code;
    }

    protected BusinessException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace,Integer code) {
        super(message, cause, enableSuppression, writableStackTrace);
        this.code = code;
    }
}

package top.hellocode.controller.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import top.hellocode.controller.results.Result;
import top.hellocode.system.exception.BusinessException;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年08月12日 9:50
 */
@Component
@ControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler(BusinessException.class)
    @ResponseBody
    public Result doBusinessException(BusinessException e){
        return new Result(e.getCode(),e.getMessage());
    }
}

注解版SSM整合

web.xml

  • 同前期设置，添加加载spring核心配置文件,生成spring核心容器(主容器/父容器/根容器）

    package top.hellocode.config;

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

import javax.servlet.*;
import java.util.EnumSet;

/**
 * @author HelloCode
 * @site https://www.hellocode.top
 * @date 2022年07月23日 15:54
 */
public class ServletContainerInitConfig extends AbstractDispatcherServletInitializer {
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMVCConfig.class);
        return ctx;
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    protected WebApplicationContext createRootApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
    }

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        super.onStartup(servletContext);

        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        FilterRegistration.Dynamic registration = servletContext.addFilter("characterEncodingFilter", filter);
        registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST,DispatcherType.FORWARD,DispatcherType.INCLUDE),false,"/*");
    }
}

  • 父容器：spring环境加载后形成的容器，包含spring环境下所有的bean

  • 子容器：当前springmvc环境加载后形成的容器，不包含spring环境下的bean

  • 子容器可以访问父容器中的资源，父容器不可用访问子容器中的资源

applicationContext.xml

//扫描组件，排除SpringMVC对应的bean，等同于
@ComponentScan(value = "com.itheima",excludeFilters = {
    @ComponentScan.Filter(type= FilterType.ANNOTATION,classes = {Controller.class})})
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MyBatisConfig.class})
//等同于，导入的默认名称为transactionManager
@EnableTransactionManagement
public class SpringConfig {
    //等同于
    @Bean("transactionManager")
    public DataSourceTransactionManager getDataSourceTxManager(@Autowired DataSource dataSource){
        DataSourceTransactionManager dtm = new DataSourceTransactionManager();
        //等同于
        dtm.setDataSource(dataSource);
        return dtm;
    }
}

spring-mvc.xml

@Configuration
@ComponentScan("test.controller")
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
}

EnableWebMvc
支持ConversionService的配置，可以方便配置自定义类型转换器
支持@NumberFormat注解格式化数字类型
支持@DateTimeFormat注解格式化日期数据，日期包括Date,Calendar,JodaTime（JodaTime要导包）
支持@Valid的参数校验(需要导入JSR-303规范)
配合第三方jar包和SpringMVC提供的注解读写XML和JSON格式数据

UserDao.xml

jdbc.properties（保留）

你可能感兴趣的:(流行框架,servlet,java,spring)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
  • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
  • web.xml报错 crabdave web.xml
    web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
  • 泛型类的自定义 麦田的设计者 javaandroid泛型
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
  • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
  • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
    1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
  • linux下安装maven 无量 mavenlinux安装
    Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
  • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
    1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
  • 关于领号活动总结 alafqq 活动
    关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
  • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
    java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
  • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
    如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
  • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
    JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
  • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
    父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
  • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
  • WAS各种脚本作用大全 ronin47 WAS 脚本
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
    借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
  • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
    Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
  • spring 定时任务中cronExpression表达式含义 chicony cronExpression
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
  • Nutz配置Jndi ctrain JNDI
    1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
  • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
  • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
      Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
  • Android实用小技巧 dcj3sjt126com android
    1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
  • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
  • 有“品”的程序员 gongmeitao 工作
    完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
  • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
  • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
    SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
  • 链表栈 luyulong java数据结构
    public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
  • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
      Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
  • spring配置定时任务 stunizhengjia springtimer
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
  • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他