eclipse搭建springmvc初步解析

spring的三大特性：IOC（控制反转），DI（依赖注入），AOP（面向切面编程）

• IOC:基于反射方式，将对象管理以bean的方式提供给spring管理，spring管理bean的基础类是BeanFactory
• DI是可以在初始化对象的时候，操作对象的属性，方法如在bean中加init-method：来初始化一个方法；destory-method：来控制对象容器被销毁的时候，如果bean被容器管理，会调用该方法，仅在scope为单例（singleton时有效）；
• AOP：是基于动态代理方式实现，主要用于操作日志，事务等的管理

pom.xml配置：

<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.scu.tgm</groupId>
  <artifactId>dubbo</artifactId>
  <packaging>war</packaging>
  <version>1.0</version>
  <name>dubbo Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
  <build>
    <finalName>dubbo</finalName>
  </build>

  <properties>
      <spring.version>4.1.6.RELEASE</spring.version>
  </properties>
  
  <dependencies>
  	 <!-- test -->
     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
         <scope>test</scope>
     </dependency>
     <dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-test</artifactId>
	    <version>${spring.version}</version>
	</dependency>

	<!-- Spring MVC support 配置了这个后就相当于也引进了spring的基本配置-->  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-webmvc</artifactId>  
        <version>${spring.version}</version>  
    </dependency>  
  </dependencies>
  
</project>

web.xml配置：mvc需要这个配置而已，单单spring不需要

<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    
  <display-name>Archetype Created Web Application</display-name>
  
  
  <servlet>
      <servlet-name>dispatcher</servlet-name>
      <!-- DispatherServlet是spring的核心类，由它开启整个服务 -->
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 这里我们手动配置查找spring配置文件的路径，如果不配置就会去/WEB-INF/中找xxx-servlet.xml -->
          <init-param>
             <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springContext.xml</param-value>
      </init-param>
      <!-- 启动容器的时候就进行初始化 -->
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>dispatcher</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

  <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

springContext.xml配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    
    <!-- 搜索spring控件，如果是注解方式采用scan扫描，我们先测试最基本的bean方式 -->
    <!-- <context:component-scan base-package="com.test"></context:component-scan> -->
    <bean name="user" class="com.scu.tgm.dubbo.entity.User" init-method="init">
    	<property name="name"  value="tgm"/>
    </bean>
    <!-- 视图页面配置 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix">
            <value>/WEB-INF/views/</value>
        </property>
        <property name="suffix">
            <value>.jsp</value>
        </property>
    </bean>
</beans>

 User:

package com.scu.tgm.dubbo.entity;

public class User {
	
	private String name;
	private Integer age;
	
	public void init() {
		age=24;
	}
	public void say() {
		System.out.println("---");
		System.out.println(this.toString());
	}

省去了setter和getter
	
}

初步解析MVC原理：

Springmvc执行流程: 

   1.用户发送一个请求到DispatcherServlet;

   2.通过HanderMapping对象去查找请求地址对应的Handler(Handler是HandlerExecutionChain对,HandlerExecutionChain=自己的Controller+N个拦截器interceptor)

   3.如果handler处理器存在,那么先会去查找能执行这个控制器对应HanderAdpter(处理适配器)

   4.先执行对应拦截器,并且拦截器是放行的;

   5.通过HanderAdpter(处理适配器)去调用我们控制器代码;并且接收ModelAndView

  6.通过视图解析器,根据我们提供的视图名,创建对应视图对象(forward:/WEB-INF/_01_hello.jsp,redirect:/WEB-INF/_01_hello.jsp) velocity

   7.通过视图和模型进行合成内容;

   8.返回结果给客户端;

 spring测试：

package dubbo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.scu.tgm.dubbo.entity.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:springContext.xml" })
public class SpringTestDemo {
	@Autowired
	BeanFactory beanFactory2;
	
	@Test
	public void test() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//spring管理bean是使用的反射方式，依赖注入IOC，与对象的构造方法无关因为获取的是DeclaredConstructor
		Class userClass=Class.forName("com.scu.tgm.dubbo.entity.User");
		Constructor declaredConstructor = userClass.getDeclaredConstructor();
		User user=(User)declaredConstructor.newInstance();	
		
		//这个是手动获取resource，与@Autowired一样
		Resource resource=new ClassPathResource("springContext.xml");
		BeanFactory beanFactory=new XmlBeanFactory(resource);
		
		//一般我们使用ApplicationContext，因为BeanFactory只提供管理bean功能，ApplicationContext继承BeanFactory并且
		//丰富了它的功能，使用ClassPathXmlApplicationContext来获取该对象
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("springContext.xml");
		User userBean3 = (User)applicationContext.getBean("user",User.class);
		
		User userBean2 = (User)beanFactory2.getBean("user",User.class);
		User userBean = (User)beanFactory.getBean("user",User.class);
		userBean.say();
		userBean2.say();
		userBean3.say();
	}

}

 测试的时候遇到一个错误：

@RunWith(SpringJUnit4ClassRunner.class)报错找不到SpringJUnit4ClassRunner.class，需要导入的包：

导入后依然报错，需要手动导入import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;