SpringMVC学习笔记--中篇

最新推荐文章于 2024-05-22 14:21:06 发布

Radan小哥

最新推荐文章于 2024-05-22 14:21:06 发布

阅读量273

点赞数

分类专栏： SpringMVC 文章标签：学习笔记 java

本文链接：https://blog.csdn.net/weixin_46625488/article/details/131652142

版权

SpringMVC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

SpringMVC学习笔记

1、跳转方式

重定向：当浏览器输入网址访问服务器时，服务器会返回另一个网址给浏览器，告诉浏览器，你用这个地址重新访问一下吧。典型的应用就是，网站迁移到新的服务器上了，但是老用户只知道旧的地址，这样就可以当用户访问旧地址时，通过重定向返回新的地址。
转发：当浏览器输入网址访问服务器时，服务器当前接口把请求转到另一个接口处理，这个过程都是服务器的行为，不会与浏览器有任何交互(即不会返回任何信息给浏览器)。
默认情况下使用的是转发，可以使用redirect：视图来进行重定向处理，视图解析器不会对重定向视图进行解析。重定向不可以访问WEB-INF目录下的资源。

1.1、ModelAndView

设置对象，根据view的名称。和视图解析器跳转到指定的页面。
页面：{视图解析器前缀}+viewName+{视图解析器后缀}

视图解析器：

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/pages/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
        <!--    这里就不在需要配置包扫描Controller、默认资源处理、注解驱动-->
    <bean name="/t1" class="com.yjr.controller.ControllerDemo"/>

对应的Controller类

//只要实现了Controller接口的类，说明这就是一个控制器了
public class ControllerDemo implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       ModelAndView modelAndView=new ModelAndView();
       modelAndView.addObject("msg","test111");
       modelAndView.setViewName("test");
       return modelAndView;
    }
}

1.2、ServletAPI

通过ServletAPI，不需要视图解析器。

通过HttpServletResponse进行输出
通过HttpServletResponse实现重定向
通过HttpServletResponse实现转发

@Controller
public class ResultGo {
@RequestMapping("/result/t1")
public void test1(HttpServletRequest req, HttpServletResponse rsp)
throws IOException {
rsp.getWriter().println("Hello,Spring BY servlet API");
}
@RequestMapping("/result/t2")
public void test2(HttpServletRequest req, HttpServletResponse rsp)
throws IOException {
rsp.sendRedirect("/index.jsp");
}
@RequestMapping("/result/t3")
public void test3(HttpServletRequest req, HttpServletResponse rsp)
throws Exception {
//转发
req.setAttribute("msg","/result/t3");
req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
}
}

1.3、SpringMVC

通过SpringMVC来实现转发和重定向-无需视图解析器
测试前，需要将视图解析器注释。

public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1() {
   //转发--在没有配置视图解析器的时候，需要写全命名，路径
        return "/WEB-INF/pages/index.jsp";
    }

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

    @RequestMapping("/rsm/t3")

    public String test3() {
//重定向
        return "redirect:/index.jsp";
    }

通过SpringMVC来实现转发和重定向-有视图解析器
默认就是转发的方式。
重定向，不需要视图解析器，本质就是重新请求一个新的地方。（注意路径问题）
但也可以重定向另外一个请求。

@Controller
public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1(){
        //转发:forward； 如果加了此关键字，视图解析器也不会对视图进行解析
        return "forward:/WEB-INF/pages/test.jsp";
        //return "forward:index";
    }
    @RequestMapping("/rsm2/hit")
    public String doHit() {
        //重定向
//        return "redirect:/hit.jsp";
        return "redirect:/WEB-INF/pages/test.jsp";
        //  redirect关键字加上后就不会对视图拼接处理了
    }
      @RequestMapping("/rsm2/t2")
    public String test2() {
        //重定向一个请求redirect:/rsm2/t1
        //重定向--访问后地址栏变为http://localhost:8080/springmvc_04_controller_war_exploded/rsm2/t1
        return "redirect:/rsm2/t1";
    }
}

2、数据处理

2.1、映射类型

2.1.1、提交的域名和处理方法的参数名一致

提交数据：http://localhost:8080/user/getName?name=zs
处理方法：

    @RequestMapping("/getName")
    public String getName(String name, Model model){
        //注意和@Param的区别
        //当请求的参数名和实体类中的参数名不一致，使用@RequestParam注解解决映射问题
        //http://localhost:8080/springmvc_04_controller_war_exploded/user/getName?username=zs
        model.addAttribute("name",name);
        System.out.println("name="+name);
        return "user";
    }

2.1.2、提交的域名和处理方法的参数名不一致

提交数据：http://localhost:8080/user/getName?username=zs
处理方法：使用@RequestParam()注解

    @RequestMapping("/getName")
    public String getName(@RequestParam("username") String name, Model model){
        //注意和@Param的区别
        //当请求的参数名和实体类中的参数名不一致，使用@RequestParam注解解决映射问题
        //http://localhost:8080/user/getName?username=zs
        model.addAttribute("name",name);
        System.out.println("name="+name);
        return "user";
    }

2.1.3、提交的是一个对象

要提交的表单域和对象的属性名一致，蚕食使用对象即可

实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;

}

提交数据：http://localhost:8080/user/getUser?name=radan&id=1&age=15
处理方法：

    //前端接受的是一个对象；id,name,age，如果使用对象，前端传递的参数名和对象名必须一致，否则就是null
    @RequestMapping("/getUser")
    public String getUser(User user,Model model)
    {
        System.out.println(user);
        model.addAttribute("user",user);
        return "test";
    }

如果使用对象，前端传递的参数名和对象名必须一致，否则就是null

2.2、数据显示到前端

2.2.1、ModelAndView

public class ControllerTest1 implements Controller {
public ModelAndView handleRequest(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) throws Exception {
//返回一个模型视图对象
ModelAndView mv = new ModelAndView();
mv.addObject("msg","ControllerTest1");
mv.setViewName("test");
return mv;
}
}

2.2.2、ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
//封装要显示到视图中的数据
//相当于req.setAttribute("name",name);
model.addAttribute("name",name);
System.out.println(name);
return "hello";
}

2.2.3、Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
//封装要显示到视图中的数据
//相当于req.setAttribute("name",name);
model.addAttribute("msg",name);
System.out.println(name);
return "test";
}

2.2.4、对比

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特
性；
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

2.3、乱码问题

SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 .
修改了xml文件需要重启服务器！

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

有些极端情况下.这个过滤器对get的支持不好 .
处理方法：

修改tomcat配置文件：设置编码！

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />

自定义过滤器

package com.yjr.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {

    public void destroy() {
    }

    public void doFilter(ServletRequest request, ServletResponse
            response, FilterChain chain) throws IOException, ServletException {
//处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
// 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest)
                request;
// 对request包装增强
        HttpServletRequest myrequest = new
                MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }

    public void init(FilterConfig filterConfig) throws
            ServletException {
    }
}
//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {
    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }


    public Map getParameterMap() {
// 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
// post请求
            try {
// 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
// get请求
            Map<String, String[]> parameterMap =
                    request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
// 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }
    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

然后在web.xml中配置这个过滤器即可！

3、整合SSM

3.1、数据库环境

CREATE DATABASE `ssmbuild`;
USE `ssmbuild`;
DROP TABLE IF EXISTS `books`;
CREATE TABLE `books` (
`bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
`bookName` VARCHAR(100) NOT NULL COMMENT '书名',
`bookCounts` INT(11) NOT NULL COMMENT '数量',
`detail` VARCHAR(200) NOT NULL COMMENT '描述',
KEY `bookID` (`bookID`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

3.2、基本环境搭建

导入相关依赖

<!--  依赖：junit，数据库驱动，连接池，Servlet，jsp，mybatis，mybatis-spring，spring,lombok-->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!--数据库驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.31</version>
    </dependency>
    <!-- 数据库连接池 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>
    <!--Servlet - JSP -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!--Mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.2</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.2</version>
    </dependency>
    <!--Spring-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>
<!--    lombok-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
    </dependency>
<!--    log4j-->

    <!--日志 start-->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.25</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-simple</artifactId>
      <version>1.7.25</version>
      <scope>test</scope>
    </dependency>
    <!--日志end-->

  </dependencies>

Maven资源过滤设置

<!--  静态资源导出-->
  <build>
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>

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

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

建立pojo，controller，mapper，service层
编写mybatis-config.xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
</configuration>

编写applicationContext.xm配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-
beans.xsd">

</beans>

3.4、Mybatis层编写

数据库配置文件db.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssmbuild?useSSl=true;useUnicode=true;characterEncoding=utf8;serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

编写mybatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
        <!--    数据库连接交给spring去做-->
        <!--    设置日志-->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

    <!--    包别名-->
    <typeAliases >
        <package name="com.yjr.pojo"/>
    </typeAliases>
    
    <!--    绑定xml文件-->
    <mappers>
        <mapper class="com.yjr.mapper.BookMapper"/>
    </mappers>

</configuration>

编写实体类并使用lombok插件

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;

}

编写mapper层的mapper接口

public interface BookMapper {
    int addBook(Books book);
    List<Books> allBook();
    //根据id删除一个Book
    int deleteBookById(int bookID);
    //根据id查询,返回一个Book
    Books queryBookByName(String bookName);

}

编写接口对应的Mapper.xml文件。需要导入Myabtis的包

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.yjr.mapper.BookMapper">
    <insert id="addBook" parameterType="books">
        insert into books(bookID,bookName,bookCounts,detail) values(#{bookID},#{bookName},#{bookCounts},#{detail})
    </insert>
    <delete id="deleteBookById">
        delete from books  where bookID=#{bookID}
    </delete>

    <select id="allBook" resultType="books">
        select * from books
    </select>
    <!--根据书名查询,返回一个Book-->
    <select id="queryBookByName" resultType="books">
        select * from books where bookName = #{bookName}
    </select>

</mapper>`

编写service层的接口和实现类
接口

public interface BookService {

    int addBook(Books book);
    List<Books> allBook();
    int deleteBookById(int bookID);
    Books queryBookByName(String bookName);
}

实现类

//@Service.---这个也可在xml中配置，这里暂时使用的是配置版
public class BookServiceImpl implements BookService {
    @Autowired
    private BookMapper bookMapper;

    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

    public int addBook(Books book) {
        return bookMapper.addBook(book);
    }

    public List<Books> allBook() {
        return bookMapper.allBook();
    }

    public int deleteBookById(int bookID) {
        return bookMapper.deleteBookById(bookID);
    }

    public Books queryBookByName(String bookName) {
        return bookMapper.queryBookByName(bookName);
    }
}

Mybatis层暂时需要配置这些

3.5、Spring层

配置Spring整合MyBatis，我们这里数据源使用c3p0连接池
编写Spring整合Mybatis的相关的配置文件； spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
            <!--    1.用spring关联数据库配置文-->
    <context:property-placeholder location="classpath:db.properties"/>

            <!--    2.连接池dbcp:半自动化操作，不能自动连续
              druid:
              cp3p0:自动化操作（自动加载配置文件，并且可以自动设置到对象中！）
              -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 配置连接池属性 -->
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!-- c3p0连接池的私有属性 -->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 关闭连接后不自动commit -->
        <property name="autoCommitOnClose" value="false"/>
        <!-- 获取连接超时时间 -->
        <property name="checkoutTimeout" value="10000"/>
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>
                <!--    3.SqlSessionFactory-->
    <bean name="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mybatis的配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
     </bean>
                <!--    4.配置mapper接口扫描包，动态实现了mapper接口可以注入到spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory的bean-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--指定扫描的mapper包 -->
        <property name="basePackage"  value="com.yjr.mapper"/>
    </bean>


</beans>

Spring整合service层

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 1.扫描service相关的bean -->
    <context:component-scan base-package="com.yjr.service" />
    <!-- 2.将所有的业务类注入到spring，BookServiceImpl注入到IOC容器中   ===》等价于@Service-->
    <bean id="BookServiceImpl" class="com.yjr.service.impl.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource" />
    </bean>
<!--    也可以配置Aop切面编程-->

</beans>

Spring层搞定!

3.6、SpringMVC层

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
  <!--DispatcherServlet-->
  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <!--一定要注意:我们这里加载的是总的配置文件，之前被这里坑了！-->
      <param-value>classpath:applicationContext.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>
  <!--encodingFilter-->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>
      org.springframework.web.filter.CharacterEncodingFilter
    </filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>utf-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!--Session过期时间-->
  <session-config>
    <session-timeout>15</session-timeout>
  </session-config>
</web-app>

spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns: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
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 配置SpringMVC -->
    <!-- 1.开启SpringMVC注解驱动 -->
    <mvc:annotation-driven />
    <!-- 2.静态资源默认servlet配置-->
    <mvc:default-servlet-handler/>
    <!-- 3.配置jsp 显示ViewResolver视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
    <!-- 4.扫描web相关的bean -->
    <context:component-scan base-package="com.yjr.controller" />
</beans>

Spring配置整合文件，applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="spring-dao.xml"/>
    <import resource="spring-service.xml"/>
    <import resource="spring-mvc.xml"/>
</beans>

配置文件，暂时结束!

Radan小哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC学习笔记--中篇

SpringMVC学习笔记文章目录SpringMVC学习笔记1、跳转方式1.1、ModelAndView1.2、ServletAPI1.3、SpringMVC2、数据处理2.1、映射类型2.1.1、提交的域名和处理方法的参数名一致2.1.2、提交的域名和处理方法的参数名不一致2.1.3、提交的是一个对象2.2、数据显示到前端2.2.1、ModelAndView2.2.2、ModelMap2.2.3、Model2.2.4、对比2.3、乱码问题3、整合SSM3.1、数据库环境3.2、基本环境搭建3.3、建立基
复制链接

扫一扫