【SSM框架学习笔记】Spring

一、Spring的loC和DI

1. Spring简介

1.1 Spring是什么

Spring是分层的JavaSE/EE应用full-stack轻量级开源框架，以loC(Inverse of Control：反转控制)和AOP(Aspect Oriented Programming：面向切面编程)为内核。

提供了展现层SpringMVC和持久层Spring　JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多的著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架。

1.2 Spring发展历程

1.3 Spring简介

1. 方便解耦，简化开发：通过Spring提供的loC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度耦合。用户也不必再为单例模式类，属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用
3. AOP编程的支持：通过Spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。
4. 声明式事务的支持：可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量。
5. 方便程序的测试：可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
6. 方便集成各种优秀的框架：Spring对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的支持。
7. 降低JavaEE API的使用难度：Spring对JavaEE API(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层，使这些API的使用难度大为降低。
8. Java源码是经典学习范例：Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无疑是Java技术的最佳实践的范例。

1.4 Spring体系结构

2. Spring快速入门

2.1 Spring程序开发步骤

1. 导入Spring开发的基本包坐标
2. 编写Dao接口和实现类
3. 创建Spring核心配置文件
4. 在Spring配置文件中配置UserDaoImpl
5. 使用Spring的API获得Bean实例

2.2 导入Spring开发的基本包实例

<properties>
<spring.version>5.0.5.RELEASE</spring.version>
</properties>
<dependencies>
<!--导入spring的context坐标，context依赖core、beans、expression-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>

2.3 编写Dao接口和实现类

public interface UserDao {
    
    
public void save();
}
public class UserDaoImpl implements UserDao {
    
    
@Override
public void save() {
    
    
	System.out.println("UserDao save method running....");
	}
}

2.4 创建Spring核心配置文件

在类路径下（resources）创建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">
</beans>

idea直接创建

2.5 在Spring配置文件中配置UserDaoImpl

<?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">
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
</beans>

2.6 使用Spring的API获得Bean实例

@Test
public void test1(){
    
    
ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
}

2.7 知识要点

Spring的开发步骤

1. 导入坐标
2. 创建Bean
3. 创建applicationContext.xml
4. 在配置文件中进行配置
5. 创建ApplicationContext对象getBean

3. Spring配置文件

3.1 Bean标签基本配置

用于配置对象交由Spring来创建。

默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

• id：Bean实例在Spring容器中的唯一标识
• class：Bean的全限定名称

3.2 Bean标签范围配置

scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	默认的，单例的
prototype	多例的
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session

1. 当scope的取值为singleton时

   Bean的实例化个数：1个

   Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

   Bean的生命周期：

   • 对象创建：当应用加载，创建容器时，对象就被创建了
   • 对象运行：只要容器在，对象一直活着
   • 对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2. 当scope的取值为prototype时

   Bean的实例化个数：多个

   Bean的实例化时机：当调用getBean()方法时实例化Bean

   Bean的生命周期：

   • 对象创建：当使用对象时，创建新的对象实例
   • 对象运行：只要对象在使用中，就一直活着
   • 对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

3.3 Bean生命周期配置

• init-method:指定类中的初始化方法名称
• destroy-method：指定类中销毁方法名称

3.4 Bean实例化三种方式

• 无参构造方法实例化

  它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

  <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
  

• 工厂静态方法实例化

  工厂的静态方法返回Bean实例

  public class StaticFactoryBean {
        
        
  public static UserDao createUserDao(){
        
        
  		return new UserDaoImpl();
  	}
  }
  

  <bean id="userDao" class="com.itheima.factory.StaticFactoryBean" 
  factory-method="createUserDao" />
  

• 工程实例方法实例化

  工厂的非静态方法返回Bean实例

  public class DynamicFactoryBean {
        
        
  public UserDao createUserDao(){
        
        
  		return new UserDaoImpl();
  	}
  }
  

  <bean id="factoryBean" class="com.itheima.factory.DynamicFactoryBean"/>
  <bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>
  

3.5 Bean的依赖注入入门

1.创建UserService，UserService 内部在调用UserDao的save()方法

public class UserServiceImpl implements UserService {
    
    
@Override
public void save() {
    
    
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	UserDao userDao = (UserDao) applicationContext.getBean("userDao");
	userDao.save();
	}
}

2.将UserServiceImpl的创建权交给Spring

<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"/>

3.从Spring容器中获得UserService进行操作

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();

3.6 Bean的依赖注入分析

目前UserService实例和UserDao实例都存在与Spring容器中，当前的做法是在容器外部获得UserService 实例和UserDao实例，然后在程序中进行结合。

因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService，所以可以在 Spring容器中，将UserDao设置到UserService内部。

3.7 Bean的依赖注入概念和方式

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。
IOC 解耦只是降低他们的依赖关系，但不会消除。
例如：业务层仍会调用持久层的方法。 那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

依赖注入方式：

1.set方法注入

在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
    
    
	private UserDao userDao;
	public void setUserDao(UserDao userDao) {
    
    
		this.userDao = userDao;
}
	@Override
	public void save() {
    
    
		userDao.save();
	}
}

配置Spring容器调用set方法进行注入

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
	<property name="userDao" ref="userDao"/>
</bean>

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：
首先，需要引入P命名空间：

xmlns:p="http://www.springframework.org/schema/p"

其次：需要修改注入方式

<bean id="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

2.构造方法注入

创建有参构造

public class UserServiceImpl implements UserService {
    
    
@Override
public void save() {
    
    
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	UserDao userDao = (UserDao) applicationContext.getBean("userDao");
	userDao.save();
	}
}

配置Spring容器调用有参构造时注入

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

3.8 Bean的依赖注入的数据类型

上面的操作，都是注入的引用Bean，处了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

注入数据的三种数据类型：1.普通数据类型 2.引用数据类型 3.集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的，下面将以set方法注入为 例，演示普通数据类型和集合数据类型的注入。

1.普通数据类型的注入

public class UserDaoImpl implements UserDao {
    
    

    private String username;
    private int age;

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public void save() {
    
    
        System.out.println(username+"====="+age);
        System.out.println("save running...");
    }
}

<bean id="userDao" class="com.yyh.impl.UserDaoImpl">
        <property name="username" value="zhangsan"/>
        <property name="age" value="18"/>
    </bean>

2.集合数据类型的注入(List)的注入

public class UserDaoImpl implements UserDao {
    
    
	private List<String> strList;
    public void setStrList(List<String> strList) {
    
    
        this.strList = strList;
    }
    public void save() {
    
    
        System.out.println(strList);
        System.out.println("UserDao save method running....");
    }
}

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
	<property name="strList">
        <list>
            <value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </property>
</bean>

3.集合数据类型(List)的注入

public class UserDaoImpl implements UserDao {
    
    
	private List<User> userList;
    public void setUserList(List<User> userList) {
    
    
        this.userList = userList;
    }
	public void save() {
    
    
        System.out.println(userList);
        System.out.println("UserDao save method running....");
	}
}

<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
    <property name="userList">
        <list>
            <bean class="com.itheima.domain.User"/>
            <bean class="com.itheima.domain.User"/>
            <ref bean="u1"/>
            <ref bean="u2"/>
        </list>
    </property>
</bean>

4.集合数据类型(Map<String,User>)的注入

public class UserDaoImpl implements UserDao {
    
    
	private Map<String,User> userMap;
    public void setUserMap(Map<String, User> userMap) {
    
    
    	this.userMap = userMap;
    }
    public void save() {
    
    
        System.out.println(userMap);
        System.out.println("UserDao save method running....");
    }
}

<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
    <property name="userMap">
        <map>
        <entry key="user1" value-ref="u1"/>
        <entry key="user2" value-ref="u2"/>
        </map>
    </property>
</bean>

5.集合数据类型(Properties)的注入

public class UserDaoImpl implements UserDao {
    private Properties properties;
    public void setProperties(Properties properties) {
    	this.properties = properties;
    }
    public void save() {
        System.out.println(properties);
        System.out.println("UserDao save method running....");
    }
}

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
    <property name="properties">
    <props>
        <prop key="p1">aaa</prop>
        <prop key="p2">bbb</prop>
        <prop key="p3">ccc</prop>
    </props>
    </property>
</bean>

3.9引入其他配置文件(分模块开发)

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他 配置文件中，而在Spring主配置文件通过import标签进行加载

<import resource="applicationContext-xxx.xml"/>

Spring的重点配置

<bean>标签
    id属性:在容器中Bean实例的唯一标识，不允许重复
    class属性:要实例化的Bean的全限定名
    scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
    <property>标签：属性注入
        name属性：属性名称
        value属性：注入的普通属性值
        ref属性：注入的对象引用值
        <list>标签
        <map>标签
    <properties>标签
    <constructor-arg>标签
<import>标签:导入其他的Spring的分文件

4. Spring相关API

4.1 ApplicationContext的继承体系

application：接口类型，代表应用上下文，可以通过其实例获得Spring容器中的Bean对象

4.2 ApplicationContext的实现类

1）ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种

2）FileSystemXmlApplicationContext 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

3）AnnotationConfigApplicationContext 当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

4.3 getBean()方法使用

public Object getBean(String name) throws BeansException {
    
    
	assertBeanFactoryActive();
	return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException {
    
    
	assertBeanFactoryActive();
	return getBeanFactory().getBean(requiredType);
}

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。 当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时， 则此方法会报错。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService1 = (UserService) applicationContext.getBean("userService");
UserService userService2 = applicationContext.getBean(UserService.class);

4.4 知识要点

Spring重要API

ApplicationContext app = new ClasspathXmlApplicationContext("xml文件")
app.getBean("id")
app.getBean(Class)

二、loC和DI的注解开发

1. Spring配置数据源

1.1 数据源(连接池)的作用和开发步骤

• 数据源(连接池)是提高程序性能出现的
• 事先实例化数据源，初始化部分连接资源
• 使用连接资源时从数据源中获取
• 使用完毕后将连接资源归还给数据源

常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等

开发步骤：

① 导入数据源的坐标和数据库驱动坐标 ② 创建数据源对象 ③ 设置数据源的基本连接数据 ④ 使用数据源获取连接资源和归还连接资源

1.2 数据源的手动创建

1.导入c3p0和druid的坐标

<!-- C3P0连接池 -->
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>
<!-- Druid连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

2.导入mysql数据库驱动坐标

<!-- mysql驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.39</version>
</dependency>

3.创建c3p0/Druid连接池

@Test
public void testC3P0() throws Exception {
    
    
    //创建数据源
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    //设置数据库连接参数
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUser("root");
    dataSource.setPassword("root");
    //获得连接对象
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}
@Test
public void testDruid() throws Exception {
    
    
    //创建数据源
    DruidDataSource dataSource = new DruidDataSource();
    //设置数据库连接参数
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    //获得连接对象
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

4.提取jdbc.properties配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

5.读取jdbc.properties配置文件创建连接池

@Test
public void testC3P0ByProperties() throws Exception {
    
    
    //加载类路径下的jdbc.properties
    ResourceBundle rb = ResourceBundle.getBundle("jdbc");
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(rb.getString("jdbc.driver"));
    dataSource.setJdbcUrl(rb.getString("jdbc.url"));
    dataSource.setUser(rb.getString("jdbc.username"));
    dataSource.setPassword(rb.getString("jdbc.password"));
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

1.3 Spring配置数据源

可以将DataSource的创建权交由Spring容器去完成
DataSource有无参构造方法，而Spring默认就是通过无参构造方法实例化对象的
DataSource要想使用需要通过set方法设置数据库连接信息，而Spring可以通过set方法进行字符串注入

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
</bean>

测试从容器当中获取数据源

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
Connection connection = dataSource.getConnection();
System.out.println(connection);

1.4 抽取jdbc配置文件

applicationContext.xml加载jdbc.properties配置文件获得连接信息。

首先，需要引入context命名空间和约束路径：

命名空间：xmlns:context=“http://www.springframework.org/schema/context”

约束路径：http://www.springframework.org/schema/context

​ http://www.springframework.org/schema/context/spring-context.xsd

<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

Spring容器加载properties文件

<context:property-placeholder location="xx.properties"/>
<property name="" value="${key}"/>

2. Spring注解开发

2.1 Spring原始注解

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置 文件可以简化配置，提高开发效率。

Spring原始注解主要是替代的配置

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法

注意： 使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean。需要进行扫描以便识别使用注解配置的类、字段和方法。

<!--注解的组件扫描-->
<context:component-scan base-package="com.itheima"></context:component-scan>

使用@Compont或@Repository(针对dao层)标识UserDaoImpl需要Spring进行实例化。

//@Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    
    
    @Override
    public void save() {
    
    
    System.out.println("save running... ...");
    }
}

使用@Component或@Service(针对service层)标识UserServiceImpl需要Spring进行实例化
使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入

//@Component("userService")
@Service("userService")
public class UserServiceImpl implements UserService {
    
    
//	@Autowired //按照数据类型从Spring容器中进行匹配的
//  @Qualifier("userDao")   	//是按照id值从容器中进行匹配的 但是主要此处@Qualifier结合@Autowired一起使用
    @Resource(name="userDao")	//@Resource相当于@Qualifier+@Autowired
    private UserDao userDao;
    @Override
    public void save() {
    
    
    userDao.save();
    }
}

使用@Value进行字符串的注入

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    
    
    @Value("注入普通数据")
    private String str;
    @Value("${jdbc.driver}")
    private String driver;
	@Override
    public void save() {
    
    
    System.out.println(str);
    System.out.println(driver);
    System.out.println("save running... ...");
    }
}

使用@Scope标注Bean的范围

//@Scope("prototype")
@Scope("singleton")
public class UserDaoImpl implements UserDao {
    
    
	//此处省略代码
}

使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法

@PostConstruct
public void init(){
    
    
	System.out.println("初始化方法....");
}
@PreDestroy
public void destroy(){
    
    
	System.out.println("销毁方法.....");
}

2.2 Spring新注解

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：
非自定义的Bean的配置： 加载properties文件的配置：<context:property-placeholder >
组件扫描的配置：<context:component-scan > 引入其他文件：

注解	说明
@Configuration	用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定 Spring 在初始化容器时要扫描的包。 作用和在 Spring 的 xml 配置文件中的<context:component-scan base-package=“com.itheima”/>一样
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource	用于加载.properties 文件中的配置
@Import	用于导入其他配置类

@Configuration @ComponentScan @Import

@Configuration
@ComponentScan("com.itheima")
@Import({
    
    DataSourceConfiguration.class})
public class SpringConfiguration {
    
    
}

@PropertySource @value

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    
    
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
}

@Bean

@Bean(name="dataSource")
public DataSource getDataSource() throws PropertyVetoException {
    
    
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);
    return dataSource;
}

测试加载核心配置类创建Spring容器

@Test
public void testAnnoConfiguration() throws Exception {
    
    
    ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    UserService userService = (UserService) app.getBean("userService");
    userService.save();
    DataSource dataSource = (DataSource) app.getBean("dataSource");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

3. Spring集成Junit

3.1 原始Junit测试Spring的问题

在测试类中，每个测试方法都有以下两行代码

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。

3.2 上述问题解决思路

• 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它。
• 将需要进行测试Bean直接在测试类中进行注入

3.3 Spring集成Junit步骤

① 导入spring集成Junit的坐标 ② 使用@Runwith注解替换原来的运行期 ③ 使用@ContextConfiguration指定配置文件或配置类 ④ 使用@Autowired注入需要测试的对象 ⑤ 创建测试方法进行测试

3.4 Spring集成Junit代码实现

导入spring集成Junit的坐标

<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.2.RELEASE</version>
    </dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

使用@Runwith注解替换原来的运行期

@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunitTest {
    
    
}

使用@ContextConfiguration指定配置文件或配置类

@RunWith(SpringJUnit4ClassRunner.class)
//加载spring核心配置文件
//@ContextConfiguration(value = {"classpath:applicationContext.xml"})
//加载spring核心配置类
@ContextConfiguration(classes = {
    
    SpringConfiguration.class})
	public class SpringJunitTest {
    
    
}

使用@Autowired注入需要测试的对象

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {
    
    SpringConfiguration.class})
public class SpringJunitTest {
    
    
	@Autowired
	private UserService userService;
}

创建测试方法进行测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {
    
    SpringConfiguration.class})
public class SpringJunitTest {
    
    
    @Autowired
    private UserService userService;
    @Test
    public void testUserService(){
    
    
    	userService.save();
    }
}

3.5 知识要点

Spring集成Junit步骤 ① 导入spring集成Junit的坐标 ② 使用@Runwith注解替换原来的运行期 ③ 使用@ContextConfiguration指定配置文件或配置类 ④ 使用@Autowired注入需要测试的对象 ⑤ 创建测试方法进行测试

4. Spring集成web环境

4.1 ApplicationContext应用上下文获取方式

应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从 容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置 文件加载多次，应用上下文对象创建多次。

在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加 载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域 中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

4.2 Spring提供获取应用上下文的工具

上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监 听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。

所以我们需要做的只有两件事： ① 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标） ② 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

4.3 导入Spring集成web的坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>

1.4 配置ContextLoaderListener监听器

<!--全局参数-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--Spring的监听器-->
<listener>
	<listener-class>
    org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

1.5 通过工具获得应用上下文对象

ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
Object obj = applicationContext.getBean("id");

1.6 知识要点

Spring集成web环境步骤

① 配置ContextLoaderListener监听器 ② 使用WebApplicationContextUtils获得应用上下文

5. SpringMVC的简介

5.1 SpringMVC概述

SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级Web 框架，属于 SpringFrameWork的后续产品，已经融合在 Spring Web Flow 中。

SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持RESTful 编程风格的请求。

5.2 SpringMVC快速入门

需求：客户端发起请求，服务器端接收请求，执行逻辑并进行视图跳转。

开发步骤： ① 导入SpringMVC相关坐标 ② 配置SpringMVC核心控制器DispathcerServlet ③ 创建Controller类和视图页面 ④ 使用注解配置Controller类中业务方法的映射地址 ⑤ 配置SpringMVC核心文件 spring-mvc.xml ⑥ 客户端发起请求测试

① 导入Spring和SpringMVC的坐标

<!--Spring坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<!--SpringMVC坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>

导入Servlet和Jsp的坐标

<!--Servlet坐标-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<!--Jsp坐标-->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
</dependency>

② 在web.xml配置SpringMVC的核心控制器

<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
	<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

③ 创建Controller和业务方法

public class QuickController {
    
    
public String quickMethod(){
    
    
    System.out.println("quickMethod running.....");
    return "index";
    }
}

创建视图页面index.jsp

<html>
<body>
	<h1>Success!</h1>
</body>
</html>

④ 配置注解

@Controller
public class QuickController {
    
    
    @RequestMapping("/quick")
    public String quickMethod(){
    
    
        System.out.println("Controller save running.....");
        return "index";
    }
}

⑤ 创建spring-mvc.xml

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        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.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置注解扫描-->
    <context:component-scan base-package="com.itheima"/>
</beans>

⑥ 访问测试地址

http://localhost:8080/quick

控制台打印

页面显示（个人设置的端口号为8089，一般是8080）

5.3 SpringMVC流程图示

5.4 知识要点

SpringMVC的开发步骤:

① 导入SpringMVC相关坐标 ② 配置SpringMVC核心控制器DispathcerServlet ③ 创建Controller类和视图页面
④ 使用注解配置Controller类中业务方法的映射地址 ⑤ 配置SpringMVC核心文件 spring-mvc.xml ⑥ 客户端发起请求测试

6. SpringMVC的组件解析

6.1 SpringMVC的执行流程

① 用户发送请求至前端控制器DispatcherServlet。
② DispatcherServlet收到请求调用HandlerMapping处理器映射器。
③ 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果 有则生成)一并返回给DispatcherServlet。
④ DispatcherServlet调用HandlerAdapter处理器适配器。
⑤ HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
⑥ Controller执行完成返回ModelAndView。
⑦ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
⑧ DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
⑨ ViewReslover解析后返回具体View。
⑩ DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户。

6.2 SpringMVC组件解析

1.前端控制器：DispatcherServlet

用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

2.处理器映射器：HandlerMapping

HandlerMapping负责根据用户请求找到Handler 即处理器，SpringMVC提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3.处理器适配器：HandlerAdapter

通过HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

4.处理器：Handler

它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由 Handler 对具体的用户请求进行处理。

5.视图解析器：View Resolver

View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成 View视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

6.视图：View

SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程 序员根据业务需求开发具体的页面

6.3 SpringMVC注解解析

@RequestMapping

作用：用于建立请求 URL 和处理请求方法之间的对应关系
位置：
类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
方法上，请求 URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径
属性：
value：用于指定请求的URL。它和path属性的作用是一样的
method：用于指定请求的方式
params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
例如：
params = {“accountName”}，表示请求参数必须有accountName
params = {“moeny!100”}，表示请求参数中money不能是100

mvc命名空间引入

命名空间：xmlns:context=“http://www.springframework.org/schema/context”

​ xmlns:mvc=“http://www.springframework.org/schema/mvc”

约束地址：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

组件扫描

SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用<context:component-scan base-package=“com.itheima.controller”/>进行组件扫描。

6.4 SpringMVC的XML配置解析

视图解析器

SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，该配置文件地址 org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下：

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

翻看该解析器源码，可以看到该解析器的默认设置，如下：

REDIRECT_URL_PREFIX = "redirect:" --重定向前缀
FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）
prefix = ""; --视图名称前缀
suffix = ""; --视图名称后缀

我们可以通过属性注入的方式修改视图的的前后缀

<!--配置内部资源视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/"></property>
<property name="suffix" value=".jsp"></property>
</bean>

6.5 知识要点

SpringMVC的相关组件

• 前端控制器：DispatcherServlet
• 处理器映射器：HandlerMapping
• 处理器适配器：HandlerAdapter
• 处理器：Handler
• 视图解析器：View Resolver
• 视图：View

SpringMVC的注解和配置

• 请求映射注解：@RequestMapping
• 视图解析器配置： REDIRECT_URL_PREFIX = “redirect:” FORWARD_URL_PREFIX = “forward:” prefix = “”; suffix = “”;

7. SpringMVC的请求和相应

7.1 SpringMVC的数据响应

1 SpringMVC的数据响应方式

1.页面跳转

• 直接返回字符串
• 通过ModelAndView对象返回

2.回写数据

• 直接返回字符串
• 返回对象或集合

2. 页面跳转

1.返回字符串形式

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

2.返回ModelAndView对象

@RequestMapping("/quick2")
public ModelAndView quickMethod2(){
    
    
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.setViewName("redirect:index.jsp");
    return modelAndView;
}
@RequestMapping("/quick3")
public ModelAndView quickMethod3(){
    
    
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.setViewName("forward:/WEB-INF/views/index.jsp");
    return modelAndView;
}

3.向request域存储数据

在进行转发时，往往要向request域中存储数据，在jsp页面中显示，那么Controller中怎样向request 域中存储数据呢？

① 通过SpringMVC框架注入的request对象setAttribute()方法设置

@RequestMapping("/quick")
public String quickMethod(HttpServletRequest request){
    
    
    request.setAttribute("name","zhangsan");
    return "index";
}

② 通过ModelAndView的addObject()方法设置

@RequestMapping("/quick3")
public ModelAndView quickMethod3(){
    
    
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.setViewName("forward:/WEB-INF/views/index.jsp");
    modelAndView.addObject("name","lisi");
    return modelAndView;
}

3. 回写数据

1.直接返回字符串

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

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

@RequestMapping("/quick4")
public void quickMethod4(HttpServletResponse response) throws 
IOException {
    
    
	response.getWriter().print("hello world");
}

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

@RequestMapping("/quick5")
@ResponseBody
public String quickMethod5() throws IOException {
    
    
	return "hello springMVC!!!";
}

在异步项目中，客户端与服务器端往往要进行json格式字符串交互，此时我们可以手动拼接json字符串返回。

@RequestMapping("/quick6")
@ResponseBody
public String quickMethod6() throws IOException {
    
    
	return "{\"name\":\"zhangsan\",\"age\":18}";
}

上述方式手动拼接json格式字符串的方式很麻烦，开发中往往要将复杂的java对象转换成json格式的字符串， 我们可以使用web阶段学习过的json转换工具jackson进行转换，导入jackson坐标。

<!--jackson-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.0</version>
</dependency>

通过jackson转换json格式字符串，回写字符串。

@RequestMapping("/quick7")
@ResponseBody
public String quickMethod7() throws IOException {
    
    
    User user = new User();
    user.setUsername("zhangsan");
    user.setAge(18);
    ObjectMapper objectMapper = new ObjectMapper();
    String s = objectMapper.writeValueAsString(user);
    return s;
}

2.返回对象或集合

通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数， 指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行如下配置：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
    <list>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"></bean>
    </list>
</property>
</bean>

@RequestMapping("/quick8")
@ResponseBody
public User quickMethod8() throws IOException {
    
    
    User user = new User();
    user.setUsername("zhangsan");
    user.setAge(18);
    return user;
}

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

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

在SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。 使用< mvc:annotation-driven/>自动加载 RequestMappingHandlerMapping（处理映射器）和 RequestMappingHandlerAdapter（ 处 理 适 配 器 ），可用在Spring-xml.xml配置文件中使用< mvc:annotation-driven/>替代注解处理器和适配器的配置。 同时使用默认底层就会集成jackson进行对象或集合的json格式字符串的转换。

4.知识要点

SpringMVC的数据响应方式：

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

7.2 SpringMVC获得请求数据

1 获得请求参数

客户端请求参数的格式是：name=value&name=value… … 服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：

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

2 获得基本类型参数

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

http://localhost:8080/itheima_springmvc1/quick9?username=zhangsan&age=12

@RequestMapping("/quick9")
@ResponseBody
public void quickMethod9(String username,int age) throws IOException {
    
    
    System.out.println(username);
    System.out.println(age);
}

3 获得POJO类型参数

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

http://localhost:8080/itheima_springmvc1/quick9?username=zhangsan&age=12

public class User {
    
    
    private String username;
    private int age;
    getter/setter…
}
@RequestMapping("/quick10")
@ResponseBody
public void quickMethod10(User user) throws IOException {
    
    
	System.out.println(user);
}

4 获得数组类型参数

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

http://localhost:8080/itheima_springmvc1/quick11?strs=111&strs=222&strs=333

@RequestMapping("/quick11")
@ResponseBody
public void quickMethod11(String[] strs) throws IOException {
    
    
	System.out.println(Arrays.asList(strs));
}

5 获得集合类型参数

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

<form action="${pageContext.request.contextPath}/quick12" method="post">
    <input type="text" name="userList[0].username"><br>
    <input type="text" name="userList[0].age"><br>
    <input type="text" name="userList[1].username"><br>
    <input type="text" name="userList[1].age"><br>
    <input type="submit" value="提交"><br>
</form>

@RequestMapping("/quick12")
@ResponseBody
public void quickMethod12(Vo vo) throws IOException {
    
    
	System.out.println(vo.getUserList());
}

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

<script>
//模拟数据
    var userList = new Array();
    userList.push({username: "zhangsan",age: "20"});
    userList.push({username: "lisi",age: "20"});
    $.ajax({
        type: "POST",
        url: "/itheima_springmvc1/quick13",
        data: JSON.stringify(userList),
        contentType : 'application/json;charset=utf-8'
    });
</script>

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

@RequestMapping("/quick13")
@ResponseBody
public void quickMethod13(@RequestBody List<User> userList) throws 
IOException {
    
    
	System.out.println(userList);
}

注意：通过谷歌开发者工具抓包发现，没有加载到jquery文件，原因是SpringMVC的前端控制器 DispatcherServlet的url-pattern配置的是/,代表对所有的资源都进行过滤操作，我们可以通过以下两种方式指定放行静态资源：

• 在spring-mvc.xml配置文件中指定放行的资源：<mvc:resources mapping=“/js/**” location=“/js/”/>

• 使用< mvc:default-servlet-handler/>标签

6 请求数据乱码问题

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

<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

7 参数绑定注解@requestParam

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

<form action="${pageContext.request.contextPath}/quick14" method="post">
    <input type="text" name="name"><br>
    <input type="submit" value="提交"><br>
</form>

@RequestMapping("/quick14")
@ResponseBody
public void quickMethod14(@RequestParam("name") String username) throws 
IOException {
    
    
	System.out.println(username);
}

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

• value：与请求参数名称
• required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
• defaultValue：当没有指定请求参数时，则使用指定的默认值赋值

@RequestMapping("/quick14")
@ResponseBody
public void quickMethod14(@RequestParam(value="name",required = false,defaultValue = "itcast") String username) throws IOException {
    
    
	System.out.println(username);
}

8 获得Restful风格的参数

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务 器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。

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

• GET：用于获取资源 /user/1 得到 id = 1 的 user

• POST：用于新建资源 /user/1 删除 id = 1 的 user

• PUT：用于更新资源 /user/1 更新 id = 1 的 user

• DELETE：用于删除资源 /user 新增 user

上述url地址/user/1中的1就是要获得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成 /user/{id}，占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作。

http://localhost:8080/itheima_springmvc1/quick19/zhangsan

9 自定义类型转换器

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

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

自定义类型转换器的开发步骤： ① 定义转换器类实现Converter接口 ② 在配置文件中声明转换器 ③ 在< annotation-driven>中引用转换器

① 定义转换器类实现Converter接口

public class DateConverter implements Converter<String,Date>{
    
    
    @Override
    public Date convert(String source) {
    
    
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        try {
    
    
            Date date = format.parse(source);
            return date;
        } catch (ParseException e) {
    
    
            e.printStackTrace();
        }
            return null;
        }
}

② 在配置文件中声明转换器

<bean id="converterService" 
    class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
        <bean class="com.itheima.converter.DateConverter"/>
        </list>
    </property>
</bean>

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

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

10 获得Servlet相关API

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

• HttpServletRequest
• HttpServletResponse
• HttpSession

@RequestMapping("/quick16")
@ResponseBody
public void quickMethod16(HttpServletRequest request,HttpServletResponse response,HttpSession session){
    
    
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
}

11 获得请求头

@RequestHeader

使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name) @RequestHeader注解的属性如下：

• value：请求头的名称
• required：是否必须携带此请求头

@RequestMapping("/quick17")
@ResponseBody
public void quickMethod17(@RequestHeader(value = "User-Agent",required = false) String headerValue){
    
    
	System.out.println(headerValue);
}

@CookieValue

使用@CookieValue可以获得指定Cookie的值 @CookieValue注解的属性如下：

• value：指定cookie的名称
• required：是否必须携带此cookie

@RequestMapping("/quick18")
@ResponseBody
public void quickMethod18(@CookieValue(value = "JSESSIONID",required = false) String jsessionid){
    
    
	System.out.println(jsessionid);
}

12 文件上传

1. 文件上传客户端三要素

• 表单项type=“file”
• 表单的提交方式是post
• 表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”

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

2. 文件上传原理

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

13 单文件上传步骤

① 导入fileupload和io坐标

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.2.2</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

② 配置文件上传解析器

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--上传文件总大小-->
    <property name="maxUploadSize" value="5242800"/>
    <!--上传单个文件的大小-->
    <property name="maxUploadSizePerFile" value="5242800"/>
    <!--上传文件的编码类型-->
    <property name="defaultEncoding" value="UTF-8"/>
</bean>

③ 编写文件上传代码

@RequestMapping("/quick20")
@ResponseBody
public void quickMethod20(String name,MultipartFile uploadFile) throws IOException {
    
    
    //获得文件名称
    String originalFilename = uploadFile.getOriginalFilename();
    //保存文件
    uploadFile.transferTo(new File("C:\\upload\\"+originalFilename));
}

14 多文件上传实现

多文件上传，只需要将页面修改为多个文件上传项，将方法参数MultipartFile类型修改为MultipartFile[]即可

<h1>多文件上传测试</h1>
<form action="${pageContext.request.contextPath}/quick21" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="name"><br>
    文件1：<input type="file" name="uploadFiles"><br>
    文件2：<input type="file" name="uploadFiles"><br>
    文件3：<input type="file" name="uploadFiles"><br>
    <input type="submit" value="提交"><br>
</form>

@RequestMapping("/quick21")
@ResponseBody
public void quickMethod21(String name,MultipartFile[] uploadFiles) throws IOException {
    
    
    for (MultipartFile uploadFile : uploadFiles){
    
    
    String originalFilename = uploadFile.getOriginalFilename();
    uploadFile.transferTo(new File("C:\\upload\\"+originalFilename));
    }
}

15 知识要点

MVC实现数据请求方式

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

MVC获取数据细节

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