• -- 启动SpringMVC的注解功能,完成请求和注解POJO的映射 --> class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> <property name="messageConverters"> <list> ...
  • SSM webapp下 访问静态资源文件出现 404 错误

    本人学JAVA4个月,菜鸟一枚,记录下我遇到的坑~

    在spring-mvc.xml文件下添加如下代码(大家可以根据需要添加自己的文件夹):

    <mvc:resources mapping="/css/**" location="/css/" cache-period="2592000"/>
    <mvc:resources mapping="/js/**" location="/js/" cache-period="31536000"/>
    <mvc:resources mapping="/**" location="/" cache-period="31536000"/>
    <mvc:default-servlet-handler/>
    
    
    至于在web.xml下添加代码的方式,本人亲测已不可行(或许以前可以),所以就用上面的方式吧。
    
    
    然而,一切准备完毕,运行项目还是出现404错误!郁闷,拿着新项目和原来可运行的项目作比较,代码丝毫不差,苦苦整了一下午,忽然灵光一闪,重新发布了下项目,就OK了。
    本人用的IDEA,放两张各位可以对照下自己配置。
    
    

    如有错误,请多多指出!


    展开全文
  • 一创建webapp项目 二处理两个问题 三直接上依赖配置pomxmlSSM框架 四配置SpringMVC 五接入Spring 六接入Mybatis MavenApp项目就自动构建成功了。 自动构建的项目,此处可能回出现index.jsp报错,java,test...

    前言:

    上一章配置好eclipse+Maven环境后,此处接着写创建webapp项目。

    一、创建webapp项目。

    file/New Maven Project/选择默认存储路径/搜索webapp/输入包名项目名等。



    MavenApp项目就自动构建成功了。

    二、处理两个问题

    1、自动构建的项目,此处可能回出现index.jsp报错。通过如下方法解决比较稳妥。

    选择项目/右键Properties/


    项目结构如下:


    2、java,test文件夹缺失。

    新建Folder--->java,test,test/java。


    构建成功之后,然后通过Maven来写一遍SpringMVC控制器。


    三、直接上依赖配置pom.xml(SSM框架)

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<groupId>com.haibo</groupId>
    	<artifactId>mvnStudy01</artifactId>
    	<packaging>war</packaging>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>mvnStudy01 Maven Webapp</name>
    	<url>http://maven.apache.org</url>
    	<!-- 初始化框架的版本号 -->
    	<properties>
    		<spring.version>4.3.3.RELEASE</spring.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>3.8.1</version>
    			<scope>test</scope>
    		</dependency>
    		<!-- 加入ServletAPI -->
    		<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>servlet-api</artifactId>
    			<version>2.3</version>
    			<scope>provided</scope>
    		</dependency>
    		<!-- MySQL依赖 start -->
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>5.1.38</version>
    		</dependency>
    		<!-- MySQL依赖 end -->
    		<!-- 加入MyBatis 依赖 start -->
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis</artifactId>
    			<version>3.2.5</version>
    		</dependency>
    		<!-- 加入MyBatis 依赖 end -->
    		<!-- Log4j start -->
    		<dependency>
    			<groupId>log4j</groupId>
    			<artifactId>log4j</artifactId>
    			<version>1.2.17</version>
    		</dependency>
    		<!-- Log4j end -->
    		<!-- 引入Spring(包含SpringMVC) 依赖 start -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-oxm</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-tx</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context-support</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-test</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<!-- 引入Spring 依赖 end -->
    		<!-- 引用c3p0 依赖 start -->
    		<dependency>
    			<groupId>com.mchange</groupId>
    			<artifactId>c3p0</artifactId>
    			<version>0.9.2.1</version>
    		</dependency>
    		<!-- 引用c3p0 依赖 end -->
    		<!-- 引用插件依赖:MyBatis整合Spring -->
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis-spring</artifactId>
    			<version>1.3.0</version>
    		</dependency>
    		<!-- JSTL -->
    		<dependency>
    			<groupId>jstl</groupId>
    			<artifactId>jstl</artifactId>
    			<version>1.2</version>
    		</dependency>
    	</dependencies>
    	<build>
    		<finalName>mvnStudy01</finalName>
    	</build>
    </project>
    
    右键项目/Maven/Update Project。更新Jar包。

    四、配置SpringMVC

    web.xml中添加Servlet:

    <!DOCTYPE web-app PUBLIC
     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    
    <web-app>
    	<display-name>Archetype Created Web Application</display-name>
    	<!-- 创建分发Servlet -->
    	<servlet>
    		<servlet-name>springmvc</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>classpath:conf/springmvc-servlet.xml</param-value>
    		</init-param>
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>springmvc</servlet-name>
    		<url-pattern>*.do</url-pattern>
    	</servlet-mapping>
    </web-app>
    
    具体这个位置classpath:conf/springmvc-servlet.xml其实就是下图这个位置:


    springmvc-servlet.xml如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:mvc="http://www.springframework.org/schema/mvc"
    	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
    		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-4.3.xsd">
    	<!-- 配置handlerMapping -->
    	<bean class="org.springframework.web.servlet.mvc.support.ControllerBeanNameHandlerMapping"></bean>
    	<!-- 配置视图解析器 -->
    	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    		<!-- 前缀 :说明如果直接放在web-inf下,不需要加前缀-->
    		<property name="prefix" value="WEB-INF/view/"></property>
    		<!-- 后缀 : -->
    		<property name="suffix" value=".jsp"></property>
    	</bean>
    	
    	
    	<!-- 加入注解驱动 -->
    	<mvc:annotation-driven></mvc:annotation-driven>
    	<!-- 扫描器 -->
    	<context:component-scan base-package="controller"></context:component-scan>
    </beans>
    
    然后扫描一下controller文件夹中的controller组件。

    package controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    @Controller
    public class HelloMvc {
    	@RequestMapping(value="/a.do",produces="text/html;charset=UTF-8")
    	public @ResponseBody String hello() {
    		return "你好";
    	}
    }
    
    顺便说一句以上代码加了中文返回处理produces="text/html;charset=UTF-8",则可以正常的显示中文。

    五、接入Spring

    在web.xml中加入配置:

    <!-- 配置Spring1:配置spring-servlet.xml路劲 -->
    	<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:conf/spring.xml</param-value>
    	</context-param>
    	<!-- 配置Spring2:配置Spring监听2 -->
    	<listener>
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    然后新建spring.xml文件在路径conf下。(此处同springmvc-servlet.xml位置)

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	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-4.3.xsd">
    	<context:component-scan base-package="model"></context:component-scan>
    </beans>
    
    在main文件下新建model,如下图

    测试一下,新建一个Person.java接口:

    package model;
    
    public interface Person {
    	void say();
    }
    
    新建一个Person的实现类:

    package model;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class Police implements Person {
    	public void say() {
    		System.out.println("我是警察");
    	}
    }
    
    修改HelloMvc写一个Controller:

    package controller;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import model.Person;
    
    @Controller
    public class HelloMvc {
    	@RequestMapping(value="/a.do",produces="text/html;charset=UTF-8")
    	public @ResponseBody String hello() {
    		return "你好";
    	}
    	@Autowired
    	Person p;
    	
    	@RequestMapping(value="/b.do",produces="text/html;charset=UTF-8")
    	public @ResponseBody String personWho() {
    		p.say();
    		return "你好,人类";
    	}
    }

    六、接入Mybatis。

    1、在conf下加入可用的数据库配置文件。


    2、修改spring.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 http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    	<context:component-scan base-package="model"></context:component-scan>
    	<context:component-scan base-package="dao"></context:component-scan>
    	<!-- 引入配置文件 -->  
        <bean id="propertyConfigurer"  
            class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
            <property name="location" value="classpath:conf/jdbc.property" />  
        </bean>  
    	<bean id="dataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource"  
            destroy-method="close">  
            <property name="driverClassName" value="${driver}" />  
            <property name="url" value="${url}" />  
            <property name="username" value="${username}" />  
            <property name="password" value="${password}" />  
            <!-- 初始化连接大小 -->  
            <property name="initialSize" value="${initialSize}"></property>  
            <!-- 连接池最大数量 -->  
            <!-- <property name="maxActive" value="${maxActive}"></property> -->  
            <!-- 连接池最大空闲 -->  
            <!-- <property name="maxIdle" value="${maxIdle}"></property>   -->
            <!-- 连接池最小空闲 -->  
            <!-- <property name="minIdle" value="${minIdle}"></property>   -->
            <!-- 获取连接最大等待时间 -->  
            <!-- <property name="maxWait" value="${maxWait}"></property>   -->
        </bean>  
        
        <!-- spring和MyBatis完美整合,不需要mybatis的配置映射文件 -->  
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
            <property name="dataSource" ref="dataSource" />  
            <!-- 自动扫描mapping.xml文件 -->  
            <property name="mapperLocations" value="classpath:mapping/*.xml"></property>  
        </bean>  
        
        <!-- DAO接口所在包名,Spring会自动查找其下的类 -->  
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
            <property name="basePackage" value="dao" />  
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>  
        </bean> 
        
        <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->  
        <bean id="transactionManager"  
            class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
            <property name="dataSource" ref="dataSource" />  
        </bean> 
    </beans>
    
    3、配置Maybtis自动生成插件

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
    <generatorConfiguration>
      <!-- 数据库驱动-->    
        <classPathEntry  location="/Users/user/Documents/maven/mysql/mysql-connector-java/5.1.38/mysql-connector-java-5.1.38.jar"/>  
        <context id="DB2Tables"  targetRuntime="MyBatis3">    
            <commentGenerator>    
                <property name="suppressDate" value="true"/>    
                <!-- 是否去除自动生成的注释 true:是 : false:否 -->    
                <property name="suppressAllComments" value="true"/>    
            </commentGenerator>    
            <!--数据库链接URL,用户名、密码 -->    
            <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/ebook" userId="root" password="haibo1118">    
            </jdbcConnection>    
            <javaTypeResolver>    
                <property name="forceBigDecimals" value="false"/>    
            </javaTypeResolver>    
            <!-- 生成模型的包名和位置-->    
            <javaModelGenerator targetPackage="model" targetProject="mvnStudy01/src/main/java">    
                <property name="enableSubPackages" value="true"/>    
                <property name="trimStrings" value="true"/>    
            </javaModelGenerator>    
            <!-- 生成映射文件的包名和位置-->    
            <sqlMapGenerator targetPackage="mapping" targetProject="mvnStudy01/src/main/java">    
                <property name="enableSubPackages" value="true"/>    
            </sqlMapGenerator>    
            <!-- 生成DAO的包名和位置-->    
            <javaClientGenerator type="XMLMAPPER" targetPackage="dao" targetProject="mvnStudy01/src/main/java">    
                <property name="enableSubPackages" value="true"/>    
            </javaClientGenerator>    
            <!-- 要生成的表 tableName是数据库中的表名或视图名 domainObjectName是实体类名-->    
            <table tableName="biquge" domainObjectName="Book" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"></table>  
        </context>    
    </generatorConfiguration>
    右键这个文件,自动在指定位置生成三个类。


    此处遇到问题有两个:

    一个是Exception in thread “main” java.lang.RuntimeException: Exception getting JDBC Driver:

    通过在generatorConfiguration中添加数据库驱动解决:

    <classPathEntry  location="/Users/user/Documents/maven/mysql/mysql-connector-java/5.1.38/mysql-connector-java-5.1.38.jar"/> 

    第二个是自动生成的时候默认的位置指定不对,改成绝对路径即可mvnStudy01/src/main/java。

    4、写service用来操作Mybatis操作数据库。

    接口:

    package service;
    
    import model.Book;
    
    public interface IBookService {
    	Book getBookById(String bookId); 
    }
    实现:

    package service;
    
    
    
    import javax.annotation.Resource;
    
    import org.springframework.stereotype.Service;
    
    import dao.BookMapper;
    import model.Book;
    
    @Service("userService")
    public class BookServiceImpl implements IBookService{
    	@Resource
    	private BookMapper bookDao;
    	
    	public Book getBookById(String bookId) {
    		// TODO Auto-generated method stub
    		return this.bookDao.selectByPrimaryKey(bookId);
    	}
    }
    

    5、写Controller用来请求操作。

    package controller;
    
    import java.io.IOException;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import model.Book;
    import model.Person;
    import service.IBookService;
    
    @Controller
    public class HelloMvc {
    	@RequestMapping(value="/a.do",produces="text/html;charset=UTF-8")
    	public @ResponseBody String hello() {
    		return "你好";
    	}
    	@Autowired
    	Person p;
    	
    	@RequestMapping(value="/b.do",produces="text/html;charset=UTF-8")
    	public @ResponseBody String personWho() {
    		p.say();
    		return "你好,人类";
    	}
    	
    	@Resource  
        private IBookService bookService = null; 
    	
    	@RequestMapping(value="/c.do",produces="text/html;charset=UTF-8")
    	public @ResponseBody String addrShow(){
    		return bookService.getBookById("59cc3a7f3ea44b15c1f92ac0").toString();
    	}
    }
    
    6、不要忘了在spring.xml中添加扫描文件夹:

    <context:component-scan base-package="model"></context:component-scan>
    	<context:component-scan base-package="dao"></context:component-scan>
    	<context:component-scan base-package="mapping"></context:component-scan>
    	<context:component-scan base-package="service"></context:component-scan>
    ok,我自测通过,完成。

    源码请去github自行下载。


































    展开全文
  • 在这个first.jsp页面展示的过程中会发送两次ajax异步请求访问webapp/images/welcome.gif以及webapp下面的menu.json文件。以前做过一个ssm项目,当初是直接在springmvc.xml中做如下配置。 < mvc

      在搭建医药集中采购系统的过程中,FirstController中通过/first访问webapp/WEB-INF/jsp下面的first.jsp。在这个first.jsp页面展示的过程中会发送两次ajax异步请求访问webapp/images/welcome.gif以及webapp下面的menu.json文件。以前做过一个ssm项目,当初是直接在springmvc.xml中做如下配置。
    < mvc:resources location=”/js/” mapping=”/js/**” />
    < mvc:resources location=”/images/” mapping=”/images/**” />
    < mvc:resources location=”/styles/” mapping=”/styles/**” />
    就可以加载静态资源了,所以我可以展示“欢迎进入”的gif图片。但是json文件怎么处理呢?参考网上资料,可以在web.xml中配置一个default拦截器的拦截资源就可以了。自己尝试了一下,做出下面的配置。
    < servlet-mapping>
      < servlet-name>default< /servlet-name>
      < url-pattern>*.json< /url-pattern>
    < /servlet-mapping>
      经过上面的配置以后,jsp页面中就可以异步请求webapp下面的静态资源了。下面给出一个我的加载页面。
      这里写图片描述
      有网友给出了springMVC加载静态资源的三种方法,我给出了自己尝试的两种,大家根据自己的需求采用不同的方法解决问题。
      
    参考资料
    http://blog.csdn.net/u012730299/article/details/51872704

    展开全文
  • 一个简单的SpringMVC程序: 我们先通过创建一个简单的动态的JavaWeb项目“springmvc01”来认识一下SpringMVC,这样方便我们对其进行分析。 1、拷贝jar包: 对于所有框架而言,这一步都是必不可少的,我们需要在web...

    一个简单的SpringMVC程序:

    我们先通过创建一个简单的动态的JavaWeb项目“springmvc01”来认识一下SpringMVC,这样方便我们对其进行分析。

    1、拷贝jar包:

    对于所有框架而言,这一步都是必不可少的,我们需要在web工程的“WEB-INF”的目录下的lib文件夹中拷贝下列jar包,由于SpringMVC是spring家族的,使用它就必不可少的要拷贝spring框架的jar包:

    • a.Spring框架的jar包:
      在这里插入图片描述
    • b.Spring框架的依赖包:
      在这里插入图片描述
    • c.SpringMVC框架的jar包:
      在这里插入图片描述
    • d.SpringMVC框架的依赖包:
      在这里插入图片描述
    2、创建一个JSP视图:

    在“WEB-INF”目录下新建一个文件夹“jsp”用于存放JSP视图,在此目录下的视图非常安全,只能通过请求转发的方式访问。我们在此创建一个视图“hello.jsp”,该视图用于在浏览器客户端响应给用户。

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    	<head>
    		<meta charset="UTF-8">
    		<title>Hello</title>
    	</head>
    	<body>
    		Hello SpringMVC
    	</body>
    </html>
    
    3、定义一个控制器Controller:

    这一步是SpringMVC框架的集中体现,之前众多Servlet现在都可以写在一个类(控制器)中,大大的简化了代码。我们在src目录下新建一个包“cn.jingpengchong.hello.controller”,在该包中新建一个类HelloController:

    package cn.jingpengchong.hello.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
    
    @Controller
    public class HelloController {
    
    	@RequestMapping("hello")
    	public String hello() {
    		return "hello";
    	}
    }
    
    • @Controller:添加该注解后该类可以被Spring扫描器到,并且告诉Spring该类是一个控制器;
    • @RequestMapping():该注解用于使处理器映射器将其value属性值与请求地址进行匹配,以确定应该执行的方法;
    4、配置spring的xml核心配置文件:

    在spring的xml核心配置文件中配置一个扫描器,用于将自定义的处理器HelloController交给Spring来管理;除此之外还需要配置一个视图解析器InternalResourceViewResolver,用来将请求匹配到的处理器返回的字符串解析成真正的请求路径:

    <?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/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
    		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-4.2.xsd">
    
    	<!-- 配置controller包扫描 -->
    	<context:component-scan base-package="cn.jingpengchong.hello"></context:component-scan>
    	<!-- 配置视图解析器:这个配置可以简化控制器中返回的请求路径 -->
    	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    		<!-- 将接受的url路径片段字符串拼接上前缀 -->
    		<property name="prefix" value="/WEB-INF/jsp/"/>
    		<!-- 将接受的url路径片段字符串拼接上后缀 -->
    		<property name="suffix" value=".jsp"/>
    	</bean>
    </beans>
    
    5、配置web.xml核心配置文件:

    要发挥控制器的作用,在这里需要配置核心控制器(或称前端控制器),并且设置哪些请求路径会被匹配到并进行处理:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
      <display-name>springmvc01</display-name>
      <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
      </welcome-file-list>
      
      <!--  核心控制器的配置 -->
    	<servlet>
    		<servlet-name>springmvc</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		<!-- DispatcherServlet继承了父类FrameworkServlet的contextConfigLocation属性,因此这里可以给个初始值 -->
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>classpath:springmvc.xml</param-value>
    		</init-param>
    		<load-on-startup>1</load-on-startup>
    	</servlet>
    
    	<servlet-mapping>
    		<servlet-name>springmvc</servlet-name>
    		<url-pattern>*.do</url-pattern>
    	</servlet-mapping>
    </web-app>
    
    6、测试:

    将此项目添加进tomcat服务器并启动tomcat服务器,打开浏览器,并在地址栏输入“http://127.0.0.1/springmvc01/hello.do”后回车,结果如下:
    在这里插入图片描述

    请求的执行过程:

    1、从在地址栏输入“http://127.0.0.1/springmvc01/hello.do”并回车,发送请求;

    在这里插入图片描述

    2、首先找到web.xml文件:

    用于该请求以“.do”结尾,所以被url-pattern标签匹配到,然后根据servlet-name标签找到核心处理器“DispatcherServlet”。
    在这里插入图片描述

    3、然后找到springmvc.xml文件:

    为核心处理器“DispatcherServlet”初始化contextConfigLocation属性时找到springmvc.xml文件。
    在这里插入图片描述

    4、然后找到HelloController.java文件:

    由于springmvc.xml文件中配置了Spring扫描器,扫描器会去“cn.jingpengchong.hello”包下逐一查找添加了特定注解的类,由于类HelloController添加了@Controller注解,所以便被扫描到,并且根据该注解断定该类是一个处理器。
    在这里插入图片描述
    在这里插入图片描述

    5、DispatcherServlet内部代码流程:

    我们知道一个请求被servlet捕获后必定会调用service方法,由service方法根据请求类别再调用doGet或doPost方法,对于DispatcherServlet也是一样。而由于DispatcherServlet没有重写其父类FrameworkServlet的service方法,因此请求必定会执行FrameworkServlet中的service():
    在这里插入图片描述
    由于“HttpMethod.PATCH == httpMethod || httpMethod == null”的返回值时false,所以调用了父类的service()方法,在其父类的service()方法中,发现其又执行了doGet()方法:
    在这里插入图片描述
    由于FrameworkService类中重写了doGet()方法,所以执行到了FrameworkService类中的doGet()方法:
    在这里插入图片描述
    在该方法中又执行了processRequest()方法,在processRequest()方法中又执行了doService()方法:
    在这里插入图片描述
    我们发现doService()方法发现其是一个抽象方法,既然是一个抽象方法,那么该类的子类必定有实现该方法的,恰巧DispatcherServlet类就是FrameworkServlet类的子类,我们点开该方法的实现,发现DispatcherServlet确实实现了该方法,那么当执行doService()方法时必定是执行DispatcherServlet类中的doService()方法了,向下执行,发现确实执行到了DispatcherServlet类中的doService()方法,并且在该方法中执行了doDispatch()方法:
    在这里插入图片描述
    在doDispatch()方法中,发现里面通过getHandler()方法获得了一个处理器映射器,该映射器获得了将要被执行的HelloController类中的hello()方法:
    在这里插入图片描述
    接着向下走,发现其又获得了一个处理器适配器,并且将处理器映射器获得的hello()方法交给该处理器适配器执行:
    在这里插入图片描述
    接着向下执行,到了processDispatchResult()方法:
    在这里插入图片描述
    在processDispatchResult()方法中又执行了render()方法:
    在这里插入图片描述
    在render()方法中又获得了一个View类的实例化对象,并调用了该对象的render()方法:
    在这里插入图片描述
    接着向下执行,发现View的render()方法其实是View的子类AbstractView中实现的方法:
    在这里插入图片描述
    在该方法中又执行了renderMergedOutputModel()方法:
    在这里插入图片描述
    接着向下执行,发现renderMergedOutputModel()方法其实是AbstractView的子类InternalResourceView中的方法:
    在这里插入图片描述
    在renderMergedOutputModel()方法中获得了一个RequestDispatcher类对象:
    在这里插入图片描述
    接着向下执行,发现在方法的最后调用了该对象的forward()方法,此时RequestDispatcher的实例化对象rd中已经有了响应的完整路径:
    在这里插入图片描述
    我们在学习Servlet时就知道了“request.getRequestDispatcher(“路径”).forward(request, response);”是一个请求转发,可见在SpringMVC中,控制器处理请求后默认是用请求转发来响应页面给用户的!为了进一步验证我们的观点,我们不妨对HelloController类中的hello()方法做一些改造,直接让它以请求转发的方式响应给用户:

    @RequestMapping("hello")
    public String hello() {
    	return "forward:/WEB-INF/jsp/hello.jsp";
    }
    

    再次发送同样的请求,我们发现,效果真实一样的!
    在这里插入图片描述
    那么用重定向的方式可以响应吗?我们试一下:

    @RequestMapping("hello")
    public String hello() {
    	return "redirect:/WEB-INF/jsp/hello.jsp";
    }
    

    在这里插入图片描述
    从上面的图中可以发现,重定向是不可以的,这也是为什么在WEB-INF目录下的jsp页面是安全的了,因为在该目录下的资源只能通过请求转发的方式访问!

    展开全文
  • 如下,在web.xml中配servlet-mapping时候,如果将DispatcherServlet请求映射配置为"/",则Spring MVC将捕获Web容器所有的请求,包括静态资源的请求,Spring MVC会将它们当成一个普通请求处理,因此找不到对应处理器...

    如下,在web.xml中配servlet-mapping时候,如果将DispatcherServlet请求映射配置为"/",则Spring MVC将捕获Web容器所有的请求,包括静态资源的请求,Spring MVC会将它们当成一个普通请求处理,因此找不到对应处理器将导致错误。

    通过该url-pattern的配置,所有URL请求都将被Spring MVC的DispatcherServlet截获,无法访问index.html,js,images等静态资源。

    web.xml
    <!-- Spring MVC servlet -->
    <servlet>
    	<servlet-name>SpringMVC</servlet-name>
    	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    	<init-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:spring-mvc.xml</param-value>
    	</init-param>
    	<load-on-startup>1</load-on-startup>
    	<async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
    	<servlet-name>SpringMVC</servlet-name>
    	<!-- 对所有请求进行拦截 -->
    	<url-pattern>/</url-pattern>
    </servlet-mapping>
    如何让Spring框架能够捕获所有URL的请求,同时又将静态资源的请求转由Web容器处理?在把DispatcherServlet的请求映射

    配置为"/"的前提下,spring提供以下解决方案:

    采用<mvc:default-servlet-handler />

    在springMVC-servlet.xml中配置<mvc:default-servlet-handler />后,会在Spring MVC上下文中定义一个org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler,它会像一个检查员,对进入DispatcherServlet的URL进行筛查,如果发现是静态资源的请求,就将该请求转由Web应用服务器默认的Servlet处理,如果不是静态资源的请求,才由DispatcherServlet继续处理。

    一般Web应用服务器默认的Servlet名称是"default",因此DefaultServletHttpRequestHandler可以找到它。如果你所有的Web应用服务器的默认Servlet名称不是"default",则需要通过default-servlet-name属性显示指定:

    <mvc:default-servlet-handler default-servlet-name="所使用的Web服务器默认使用的Servlet名称" />

    如下配置片段:

    spring-mvc.xml
    <!-- 定义跳转的文件的前后缀 ,视图模式配置 -->
    <bean
    	class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    	<!-- 前缀和后缀,变成一个可用的url地址 -->
    	<property name="prefix" value="/WEB-INF/jsp/" />
    	<property name="suffix" value=".jsp" />
    </bean>
    
    
    <!-- 解除servlet对静态资源文件访问的限制 -->  
    <mvc:default-servlet-handler/>  

    这样就可以成功的访问静态资源了

    展开全文
  • 前言:最近从网上找课程学ssm整合实战,感觉跟着敲肯定会多少对SSM框架有更深的认识,然而。。照着敲都出现了BUG,花费了我四天是时间才勉强解决了,尤其是当你没有小伙伴询问的条件下,想必一定是痛苦万分(跟我...
  • 我已经加入配置文件了 **" /> 是不是还好什么必要的设置呀? 我的正常跳转是可以的,就是无法访问静态资源
  • 成功启动Tomcat的log信息,可以发现Spring成功初始化了。src/main/webapp加入到部署中
  • 工作中我们或多或少都需要自己搭建一个框架,现在常见的Java开源框架组合方式主要为:SSH,spring+springMVC+JDBC,SSM。 其中SSM目前无论是培训机构培训亦或是招聘。都会将会使用SSM框架作为一个重要能力来作为...
  • SSM框架是目前企业比较常用的框架之一,它的灵活性、安全性相对于SSH有一定的优势。说到这,谈谈SSM和SSH的不同点,这也是企业常考初级程序员的面试题之一。说到这两套框架的不同,主要是持久层框架Hibernate和...
  • 1、删除webapp/WEB-INF下的web.xml文件。web.xml文件主要作用是配置springMVC的dispatcherservlet,dispatcherservlet是springMVC中前端控制器,负责分发请求。springboot已经帮我们自动配置好了dispatcherservlet,...
  • 相信有许多的小伙伴在刚接触idea的时候会遇到在eclipse上运行...1.找到Project Strucure 页面将 Web Resource Directories的资源目录改为webapp 修改完之后你的webapp(文件夹里有蓝点)变为这个样子就说明你资源...
  • 小疯手把手带你整合SpringMVC+Spring+MyBatis三大框架,俗称SSM,用它完全代替传统的SSH框架,把它们最优雅的一面发挥出来。整合配置结束后,会有一个应用实例“图书管理系统”带给大家,希望能快速上手这个框架!
  • SSM 博客系统开发实战

    2019-07-05 10:16:32
    SSM 框架即 SpringMVC+Spring+Mybatis,相比 SSH(Struts2+Spring+Hibernate)来说较新,SpringMVC 可与 Spring 更好的整合,Mybatis 相比 Hibernate 使用更简单、轻便,大部分公司都在使用 SSM 这套框架,主要是轻...
  • 首先说明这是我一个不熟悉idea和SSM框架的新手小白遇到的坑,适合用idea搭建SSM框架的小伙伴看一看,老鸟就不用看了。以下为详细步骤(傻瓜教程,超级细节)搭建SSM框架的前提当然是我们已经准备好一下环境安装好的...
  • 在建包的时候不小心把包建在了src目录下,相当于类名就为 controller。在通过注解扫描&lt;context:component-scan base-package=".../&gt;时,其实并没有真正找到controller类,也就没有映射...
  • 今天在做一个SSM项目的时候遇到了一个很奇怪的bug,直接上图: webapp目录结构如下: webapp目录下的login.jsp文件里的部分内容(注意路径,是相对路径): 可是当我访问login.jsp文件的时候,link标签引入的...
  • 自己接触ssm框架有一段时间了,从最早的接触新版ITOO项目的(SSM/H+Dobbu zk),再到自己近期来学习到的《淘淘商城》一个ssm框架的电商项目。用过,但是还真的没有自己搭建过,一直都是用别人搭建好的。所以,从网上...
  • Spring+SpringMVC+Mybatis 框架已经搭建完成,其中...此篇整理前端页面发送ajax 请求到后端,后端通过 Mybatis 链接数据库,返回JSON数据给前端页面,完成显示功能。一、在webapp目录下建立 index.jsp ,将前端内容...
1 2 3 4 5 ... 20
收藏数 4,491
精华内容 1,796