目录
- BeanFactory与ApplicationContext的关系
工厂方式实例化：底层通过调用自定义的工厂方法对Bean进行实例化
Bean工厂后处理器 – BeanFactoryPostProcessor
多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖"，也叫做"循环引用"
-Spring xml方式整合第三方框架--Spring整合MyBatis
基于xml的Spring应用
BeanFactory快速入门
<!--Spring核心-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.7</version>
</dependency>public interface UserDao {}
public class UserDaoImpl implements UserDao {}public interface UserService {}
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao (UserDao userDao){
System.out.println("注入userDao"+userDao);
this.userDao=userDao;
}
}
3）配置beans.xml文件
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean> //创建工厂对象
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
//创建一个读取器（xml文件）
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
//读取配置给工厂
reader.loadBeanDefinitions("beans.xml");
//根据id获取Bean实例对象
UserService userService = (UserService) beanFactory.getBean("userService");
System.out.println(userService);- ApplicationContext快速入门
//创建ApplicationContext,加载配置文件，实例化容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//根据beanName获得容器中的Bean实例
UserService userService = (UserService) applicationContext.getBean("userService");
System.out.println(userService);
- BeanFactory与ApplicationContext的关系
- BeanFactory的继承体系
- ApplicationContext的继承体系
- SpringBean 的配置详解
Bean的范围配置
Bean的延迟加载
Bean的初始化和销毁方法配置
public class UserDaoImpl implements UserDao, InitializingBean {
public UserDaoImpl() {System.out.println("UserDaoImpl创建了...");}
public void init(){System.out.println("初始化方法...");}
public void destroy(){System.out.println("销毁方法...");}
//执行时机早于init-method配置的方法
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean...");
}
}Bean的实例化配置
构造方式实例化：底层通过构造方法对Bean进行实例化
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<constructor-arg name="name" value="haohao"/>
</bean>工厂方式实例化：底层通过调用自定义的工厂方法对Bean进行实例化
工厂方式实例化Bean，又分为如下三种：
静态工厂方法实例化Bean
静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其 静态方法配置给Spring即可
//工厂类
public class UserDaoFactoryBean {
//非静态工厂方法
public static UserDao getUserDao(String name){
//可以在此编写一些其他逻辑代码
return new UserDaoImpl();
}
}<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean" factorymethod="getUserDao">
<constructor-arg name="name" value="haohao"/>
</bean>PS：标签不仅仅是为构造方法传递参数，只要是为了实例化对象而传递的参数都可以通过 标签完成，例如上面通过静态工厂方法实例化Bean所传递的参数也是要通过 进行传递的
实例工厂方法实例化Bean
实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂 对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean
//工厂类
public class UserDaoFactoryBean2 {
//非静态工厂方法
public UserDao getUserDao(String name){
//可以在此编写一些其他逻辑代码
return new UserDaoImpl();
}
}<!-- 配置实例工厂Bean -->
<bean id="userDaoFactoryBean2" class="com.itheima.factory.UserDaoFactoryBean2"/>
<!-- 配置实例工厂Bean的哪个方法作为工厂方法 -->
<bean id="userDao" factory-bean="userDaoFactoryBean2" factory-method="getUserDao">
<constructor-arg name="name" value="haohao"/>
</bean>实现FactoryBean规范延迟实例化Bean
上面不管是静态工厂方式还是非静态工厂方式，都是自定义的工厂方法，Spring提供了FactoryBean的接口规范， FactoryBean接口定义如下：
public interface FactoryBean<T> {
String OBJECT_TYPE_ATTRIBUTE = “factoryBeanObjectType”
;
T getObject() throws Exception; //获得实例对象方法
Class<?> getObjectType(); //获得实例对象类型方法
default boolean isSingleton() {
return true;
}
}public class UserDaoFactoryBean3 implements FactoryBean<UserDao> {
public UserDao getObject() throws Exception {
return new UserDaoImpl();
}
public Class<?> getObjectType() {
return UserDao.class;
}
}配置FactoryBean交由Spring管理即可
<bean id="userDao3" class="com.itheima.factory.UserDaoFactoryBean3"/>通过断点观察发现Spring容器创建时，FactoryBean被实例化了，并存储到了单例池singletonObjects中，但是 getObject() 方法尚未被执行，UserDaoImpl也没被实例化，当首次用到UserDaoImpl时，才调用getObject() ， 此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池 中，并且后期每次使用到userDao都从该缓存池中返回的是同一个userDao实例。
Bean的依赖注入配置
Bean的依赖注入有两种方式：
其中，ref 是 reference 的缩写形式，翻译为：涉及，参考的意思，用于引用其他Bean的id。value 用于注入普通 属性值。
依赖注入的数据类型有如下三种:
普通数据类型，例如：String、int、boolean等，通过value属性指定。
引用数据类型，例如：UserDaoImpl、DataSource等，通过ref属性指定。
集合数据类型，例如：List、Map、Properties等。
注入 List 集合
//普通数据
private List<String> strList;
public void setStrList(List<String> strList) {
strList.forEach(str->{
System.out.println(str);
});
}
//引用数据
private List<UserDao> objList;
public void setObjList(List<UserDao> objList) {
objList.forEach(obj-> System.out.println(obj));
}<!--普通数据-->
<property name="strList">
<list>
<value>aaa</value>
<value>bbb</value>
<value>bbb</value>
</list>
</property>
<!---引用数据-->
<property name="objList">
<list>
<bean class="com.itheima.dao.impl.UserDaoImpl"></bean>
<bean class="com.itheima.dao.impl.UserDaoImpl"></bean>
<bean class="com.itheima.dao.impl.UserDaoImpl"></bean>
</list>
</property>注入 Map 集合
//注入值为字符串的Map集合
public void setValueMap(Map<String,String> valueMap){
valueMap.forEach((k,v)->{
System.out.println(k+"=="+v);
});
}
//注入值为对象的Map集合
public void setObjMap(Map<String,UserDao> objMap){
objMap.forEach((k,v)->{
System.out.println(k+"=="+v);
});
}
<!--注入值为字符串的Map集合-->
<property name="valueMap">
<map>
<entry key="aaa" value="AAA" />
<entry key="bbb" value="BBB" />
<entry key="ccc" value="CCC" />
</map>
</property>
<!--注入值为对象的Map集合-->
<property name="objMap">
<map>
<entry key="ud" value-ref="userDao"/>
<entry key="ud2" value-ref="userDao2"/>
<entry key="ud3" value-ref="userDao3"/>
</map>
</property>自动装配方式
如果被注入的属性类型是Bean引用的话，那么可以在 标签中使用 autowire 属性去配置自动注入方式，属 性值有两个：
byName：通过属性名自动装配，即去匹配 setXxx 与 id="xxx"（name="xxx"）是否一致； byType：通过Bean的类型从容器中匹配，匹配出多个相同Bean类型时，报错。
- Spring 的get方法
//根据beanName获取容器中的Bean实例，需要手动强转
UserService userService = (UserService) applicationContext.getBean("userService");
//根据Bean类型去容器中匹配对应的Bean实例，如存在多个匹配Bean则报错
UserService userService2 = applicationContext.getBean(UserService.class);
//根据beanName获取容器中的Bean实例，指定Bean的Type类型
UserService userService3 = applicationContext.getBean("userService", UserService.class);- Spring 配置非自定义Bean
以上在 xml 中配置的Bean都是自己定义的，例如：UserDaoImpl，UserServiceImpl。但是，在实际开发中有些 功能类并不是我们自己定义的，而是使用的第三方jar包中的，那么，这些Bean要想让Spring进行管理，也需要对 其进行配置
配置非自定义的Bean需要考虑如下两个问题：
被配置的Bean的实例化方式是什么？无参构造、有参构造、静态工厂方式还是实例工厂方式
被配置的Bean是否需要注入必要属性。
1）配置 Druid 数据源交由Spring管理
导入Druid坐标
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
<!-- druid数据源 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.23</version>
</dependency>配置 DruidDataSource
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>2）配置日期对象交由Spring管理
产生一个指定日期格式的对象，原始代码按如下：
String currentTimeStr = "2023-08-27 07:20:00";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = simpleDateFormat.parse(currentTimeStr);可以看成是实例工厂方式，使用Spring配置方式产生Date实例
<bean id="simpleDateFormat" class="java.text.SimpleDateFormat">
<constructor-arg name="pattern" value="yyyy-MM-dd HH:mm:ss"/>
</bean>
<bean id="date" factory-bean="simpleDateFormat" factory-method="parse">
<constructor-arg name="source" value="2023-08-27 07:20:00"/>
</bean>3）配置MyBatis的SqlSessionFactory交由Spring管理
导入MyBatis的相关坐标：
<!--mybatis框架-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.5</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
MyBatis原始获得SqlSessionFactory的方式：
//加载mybatis核心配置文件，使用Spring静态工厂方式
InputStream in = Resources.getResourceAsStream(“mybatis-conifg.xml”);
//创建SqlSessionFactoryBuilder对象，使用Spring无参构造方式
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//调用SqlSessionFactoryBuilder的build方法，使用Spring实例工厂方式
SqlSessionFactory sqlSessionFactory = builder.build(in);
SqlSessionFactory交由Spring管理配置如下：
<bean id="in" class="org.apache.ibatis.io.Resources" factory-method="getResourceAsStream">
<constructor-arg name="resource" value="mybatis-config.xml"></constructor-arg>
</bean>
<bean id="builder" class="org.apache.ibatis.session.SqlSessionFactoryBuilder"></bean>
<bean id="sqlSessionFactory" factory-bean="builder" factory-method="build">
<constructor-arg name="inputStream" ref="in"></constructor-arg>
</bean>- Bean 实例化的基本流程
加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefinition对象;
将BeanDefinition存储在一个名为beanDefinitionMap的Map中;
ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象;
创建好的Bean实例对象，被存储到一个名为singletonObjects的Map中;
当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回。
Spring容器在进行初始化时，会将xml配置的的信息封装成一个BeanDefinition对象，所有的 BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用getBean方法 时则最终从该Map集合中取出Bean实例对象返回。
DefaultListableBeanFactory对象内部维护着一个Map用于存储封装好的BeanDefinitionMap
public class DefaultListableBeanFactory extends ... implements ... {
//存储<bean>标签对应的BeanDefinition对象
//key:是Bean的beanName，value:是Bean定义对象BeanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap;
}
Spring框架会取出beanDefinitionMap中的每个BeanDefinition信息，反射构造方法或调用指定的工厂方法 生成Bean实例对象，所以只要将BeanDefinition注册到beanDefinitionMap这个Map中，Spring就会进行对 应的Bean的实例化操作
- Spring的后处理器
Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册 BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。Spring主要有两种后处理器：
BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行;
BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行。
Bean工厂后处理器 – BeanFactoryPostProcessor
BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回 调该接口的方法，用于对BeanDefinition注册和修改的功能。
BeanFactoryPostProcessor 定义如下：
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory);
}编写BeanFactoryPostProcessor
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException{
System.out.println("MyBeanFactoryPostProcessor执行了...");
}
}
配置BeanFactoryPostProcessor
<bean class="com.itheima.processor.MyBeanFactoryPostProcessor"/>postProcessBeanFactory 参数本质就是 DefaultListableBeanFactory，拿到BeanFactory的引用，自然就可以 对beanDefinitionMap中的BeanDefinition进行操作了 ，例如对UserDaoImpl的BeanDefinition进行修改操作
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
BeanDefinition userDaoBD = beanFactory.getBeanDefinition(“userDao”);//获得UserDao定义对象
userDaoBD.setBeanClassName("com.itheima.dao.impl.UserDaoImpl2"); //修改class
//userDaoBD.setInitMethodName(methodName); //修改初始化方法
//userDaoBD.setLazyInit(true); //修改是否懒加载
//... 省略其他的设置方式 ...
}
}上面已经对指定的BeanDefinition进行了修改操作，下面对BeanDefiition进行注册操作
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory)
throws BeansException {
//强转成子类DefaultListableBeanFactory
if(configurableListableBeanFactory instanceof DefaultListableBeanFactory){
DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory)
configurableListableBeanFactory;
BeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClassName("com.itheima.dao.UserDaoImpl2");
//进行注册操作
beanFactory.registerBeanDefinition("userDao2",beanDefinition);
}
}
}Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor专门用于注册 BeanDefinition操作
public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory
configurableListableBeanFactory) throws BeansException {}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry)
throws BeansException {
BeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClassName("com.itheima.dao.UserDaoImpl2");
beanDefinitionRegistry.registerBeanDefinition("userDao2",beanDefinition);
}
}案例:
自定义@MyComponent注解，使用在类上
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {
//显示的指定Bean的beanName
String value() default "";
}
在类上使用@MyComponent
@MyComponent("otherBean")
public class OtherBean {
}自定义BeanFactoryPostProcessor完成注解解析
public class MyComponentBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
//指定要扫描的包
String basePackage = "com.itheima";
//调用扫描工具扫描指定包及其子包下的@MyComponent
Map<String, Class> myComponentClassMap =
BaseClassScanUtils.scanMyComponentAnnotation(basePackage);
//遍历Map集合，创建BeanDefinition对象进行注册
myComponentClassMap.forEach((beanName,clazz)->{
try {
BeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClassName(clazz.getName());
registry.registerBeanDefinition(beanName,beanDefinition);
} catch (Exception e) {
e.printStackTrace();
}
});
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
}
}
配置MyComponentBeanDefinitionRegistryPostProcessor
<bean class="com.itheima.processor.MyComponentBeanDefinitionRegistryPostProcessor"></bean>Bean后处理器 – BeanPostProcessor
Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程，例如：属性的 填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟上面的 Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被 Spring自动调用。
BeanPostProcessor的接口定义如下：
public interface BeanPostProcessor {
@Nullable
//在属性注入完毕，init初始化方法执行之前被回调
default Object postProcessBeforeInitialization(Object bean, String beanName) throws
BeansException {
return bean;
}
@Nullable
//在初始化方法执行之后，被添加到单例池singletonObjects之前被回调
default Object postProcessAfterInitialization(Object bean, String beanName) throws
BeansException {
return bean;
}
}自定义MyBeanPostProcessor
public class MyBeanPostProcessor implements BeanPostProcessor {
/* 参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
返回值：当前Bean实例对象 */
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("BeanPostProcessor的before方法...");
return bean;
}
/* 参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
返回值：当前Bean实例对象 */
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("BeanPostProcessor的after方法...");
return bean;
}
}
配置MyBeanPostProcessor
<bean class="com.itheima.processors.MyBeanPostProcessor"></bean>
编写BeanPostProcessor，增强逻辑编写在 after方法中
ublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
//对Bean进行动态代理，返回的是Proxy代理对象
Object proxyBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(),
bean.getClass().getInterfaces(),
(Object proxy, Method method, Object[] args) -> {
long start = System.currentTimeMillis();
System.out.println("开始时间：" + new Date(start));
//执行目标方法
Object result = method.invoke(bean, args);
long end = System.currentTimeMillis();
System.out.println("结束时间：" + new Date(end));
return result;
});
//返回代理对象
return proxyBean;
}
- Spring Bean的生命周期
Spring Bean的生命周期是从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储 到单例池中，这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为三个阶段：
Bean的实例化阶段：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的， 是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化；
Bean的初始化阶段：Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware 接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法 等。该阶段是Spring最具技术含量和复杂度的阶段，Aop增强功能，后面要学习的Spring的注解功能等、 spring高频面试题Bean的循环引用问题都是在这个阶段体现的；
Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池 singletonObjects中去了，即完成了Spring Bean的整个生命周期。
由于Bean的初始化阶段的步骤比较复杂，所以着重研究Bean的初始化阶段
Spring Bean的初始化过程涉及如下几个过程：
>Bean实例的属性填充
>Aware接口属性注入
>BeanPostProcessor的before()方法回调
>InitializingBean接口的初始化方法回调
>自定义初始化方法init回调
> BeanPostProcessor的after()方法回调
BeanDefinition 中有对当前Bean实体的注入信息通过属性propertyValues进行了存储，例如UserService的属性信 息如下:
Spring在进行属性注入时，会分为如下几种情况：
>注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去；
>注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被 注入对象Bean实例（完成整个生命周期）后，在进行注入操作；
>注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）问题
多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖"，也叫做"循环引用"
Spring提供了三级缓存存储 完整Bean实例 和 半成品Bean实例 ，用于解决循环引用问题 在DefaultListableBeanFactory的上四级父类DefaultSingletonBeanRegistry中提供如下三个Map：
public class DefaultSingletonBeanRegistry ... {
//1、最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为"一级缓存"
Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
//2、早期Bean单例池，缓存半成品对象，且当前对象已经被其他对象引用了，称之为"二级缓存"
Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);
//3、单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时在通过工厂创建Bean，称之为"三级缓存"
Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
}
Spring Bean的生命周期--常用的Aware接口
Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口。框架具备高度封装性，我们接 触到的一般都是业务代码，一个底层功能API不能轻易的获取到，但是这不意味着永远用不到这些对象，如果用到了 ，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象。
- Spring IoC容器实例化bean整体流程图(*)
-Spring xml方式整合第三方框架--Spring整合MyBatis
配置SqlSessionFactoryBean和MapperScannerConfigurer
<!--配置数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!--配置SqlSessionFactoryBean-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置Mapper包扫描-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.itheima.dao"></property>
</bean>
1. sqlsessionfactory实现了initializingbean也就是说在sqlsessionfactory的生命周期的初始化过程中会调用afterpropertiesset，通过afterpropertiesset去调用buildsqlsessionfactory函数给this.sqlsessionfactory赋值。然后sqlsessionfactory实现了factorybean接口实现了延迟加载bean，自身有属性sqlsessionfactory当调用factorybean的getObject方法是返回自己的sqlsessionfactory,如果sqlsessionfactory为空就区再次调用一次afterpropertiesset去给sqlsessionfactory赋值.
2.mapperscannerconfigurer实现了Beandefinitionregistrypostprocessor，所以会在bean实例化之前执行postProcessBeanDefinitionRegistry,在该方法里面定义了一个classpathmapperscanner的对象，然后会执行该对象的scan方法（传入basepackage）。scan方法在该对象的父类之中,会执行this.doscan去调用子类的doscan方法（里面会执行两个方法）,然后子类的doscan方法会回去调用父类的doscan方法去把beandifinition注册到beandifinitionmap之中此时beanClass为mapper接口的全限定名.此时父类doscan方法执行完去执行子类doscan方法的下一个方法processbeandefinitions,这个方法首先将beanclass改为mapperfactorybean的全限定名，里面的getobject方法会执行sqlsessesion的getmapper，然后修改了自动注入状态，所以 MapperFactoryBean中的setSqlSessionFactory会自动注入进去。
了外部命名空间标签的执行流程，如下：
Spring xml方式整合第三方框架--自定义命名空间
步骤分析：
1. 确定命名空间名称、schema虚拟路径、标签名称；
2. 编写schema约束文件haohao-annotation.xsd
3. 在类加载路径下创建META-INF目录，编写约束映射文件spring.schemas和处理器映射文件spring.handlers
4. 编写命名空间处理器 HaohaoNamespaceHandler，在init方法中注册HaohaoBeanDefinitionParser
5. 编写标签的解析器 HaohaoBeanDefinitionParser，在parse方法中注册HaohaoBeanPostProcessor
6. 编写HaohaoBeanPostProcessor
==========以上五步是框架开发者写的，以下是框架使用者写的===========
1. 在applicationContext.xml配置文件中引入命名空间
2. 在applicationContext.xml配置文件中使用自定义的标签
基于注解的Spring应用
Bean基本注解开发
使用注解对需要被Spring实例化的Bean进行标注，但是需要告诉Spring去哪找这些Bean，要配置组件扫描路径
<?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
">
<!-- 告知Spring框架去itheima包及其子包下去扫描使用了注解的类 -->
<context:component-scan base-package="com.itheima"/>
</beans>使用@Component 注解替代标签
可以通过@Component注解的value属性指定当前Bean实例的beanName，也可以省略不写，不写的情况下为当前 类名首字母小写
//获取方式：applicationContext.getBean("userDao");
@Component("userDao")
public class UserDaoImpl implements UserDao {
}
//获取方式：applicationContext.getBean("userDaoImpl");
@Component
public class UserDaoImpl implements UserDao {
}
@Component("userDao")
@Scope("singleton")
@Lazy(true)
public class UserDaoImpl implements UserDao{
@PostConstruct
public void init(){}
@PreDestroy
public void destroy(){}
}由于JavaEE开发是分层的，为了每层Bean标识的注解语义化更加明确，@Component又衍生出如下三个注解：
@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Service("userService")
public class UserServiceImpl implements UserService{}
@Controller("userService")
public class UserController {}Spring主要提供如下注解，用于在Bean内部进行属性注入的：
通过@Value 直接注入普通属性
@Value("haohao")
private String username;
@Value("haohao")
public void setUsername(String username){
System.out.println(username);
}
通过@Value 注入properties文件中的属性
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.username}")
public void setUsername(String username){
System.out.println(username);
}加载properties文件
<context:property-placeholder location="classpath:jdbc.properties"/>
@Autowired注解，用于根据类型进行注入
//使用在属性上直接注入
@Autowired
private UserDao userDao;
//使用在方法上直接注入
@Autowired
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}
当容器中同一类型的Bean实例有多个时，会尝试自动根据名字进行匹配,如果名字与被注入Bean名称不匹配时会报错
@Qualifier配合@Autowired可以完成根据名称注入Bean实例，使用@Qualifier指定名称
@Autowired
@Qualifier("userDao2")
private UserDao userDao;
@Autowired
@Qualifier("userDao2")
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}@Resource注解既可以根据类型注入，也可以根据名称注入，无参就是根据类型注入，有参数就是根据名称注入
@Resource
private UserDao userDao;
@Resource(name = "userDao2")
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}
PS：@Resource注解存在与 javax.annotation 包中，Spring对其进行了解析
非自定义Bean注解开发
非自定义Bean不能像自定义Bean一样使用@Component进行管理，非自定义Bean要通过工厂的方式进行实例化，使用@Bean标注方法即可，@Bean的属性为beanName，如不指定，则为当前工厂方法名称
//将方法返回值Bean实例以@Bean注解指定的名称存储到Spring容器中
@Bean("dataSource")
public DataSource dataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");
dataSource.setUsername("root");
dataSource.setPassword("root");
return dataSource;
}PS：工厂方法所在类必须要被Spring管理
@Bean
public Object objectDemo02(@Qualifier("userDao") UserDao userDao,
@Value("${jdbc.username}") String username){
System.out.println(userDao);
System.out.println(username);
return new Object();
}Bean配置类的注解开发
@Configuration注解标识的类为配置类，替代原有xml配置文件，该注解第一个作用是标识该类是一个配置类，第 二个作用是具备@Component作用
@ComponentScan 组件扫描配置，替代原有xml文件中的
@Configuration
@ComponentScan
@PropertySource("classpath:jdbc.properties")
@Import(OtherConfig.class)
public class ApplicationContextConfig {}Spring 配置其他注解
扩展：@Primary注解用于标注相同类型的Bean优先被使用权，@Primary 是Spring3.0引入的，与@Component 和@Bean一起使用，标注该Bean的优先级更高，则在通过类型获取Bean或通过@Autowired根据类型进行注入时， 会选用优先级更高的
@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Repository("userDao2")
@Primary
public class UserDaoImpl2 implements UserDao{}
@Bean
public UserDao userDao01(){return new UserDaoImpl();}
@Bean
@Primary
public UserDao userDao02(){return new UserDaoImpl2();}扩展：@Profile 注解的作用同于xml配置时学习profile属性，是进行环境切换使用的
<beans profile="test">注解 @Profile 标注在类或方法上，标注当前产生的Bean从属于哪个环境，只有激活了当前环境，被标注的Bean才 能被注册到Spring容器里，不指定环境的Bean，任何环境下都能注册到Spring容器里
@Repository("userDao")
@Profile("test")
public class UserDaoImpl implements UserDao{}
@Repository("userDao2")
public class UserDaoImpl2 implements UserDao{}
Spring注解的解析原理
使用@Component等注解配置完毕后，要配置组件扫描才能使注解生效
xml配置组件扫描：
<context:component-scan base-package="com.itheima"/>
配置类配置组件扫描：
@Configuration
@ComponentScan("com.itheima")
public class AppConfig {
}使用配置类配置组件扫描，使用AnnotationConfigApplicationContext容器在进行创建时，内部调用了如下代码， 该工具注册了几个Bean后处理器：
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
Spring注解方式整合第三方框架
第三方框架整合，依然使用MyBatis作为整合对象，之前我们已经使用xml方式整合了MyBatis，现在使用注解方式 无非就是将xml标签替换为注解，将xml配置文件替换为配置类而已，原有xml方式整合配置如下
<!--配置数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!--配置SqlSessionFactoryBean-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置Mapper包扫描-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.itheima.dao"></property>
</bean>
使用@Bean将DataSource和SqlSessionFactoryBean存储到Spring容器中，而MapperScannerConfigurer使用注 解@MapperScan进行指明需要扫描的Mapper在哪个包下，使用注解整合MyBatis配置方式如下：
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@MapperScan("com.itheima.mapper")
public class SpringConfig {
@Bean
public DataSource dataSource(
@Value("${jdbc.driverClassName}") String driver,
@Value("${jdbc.url}") String url,
@Value("${jdbc.username}") String username,
@Value(("${jdbc.password}")) String password
){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
return sqlSessionFactoryBean;
}
}注解方式，Spring整合MyBatis的原理，关键在于@MapperScan，@MapperScan不是Spring提供的注解，是 MyBatis为了整合Spring，在整合包org.mybatis.spring.annotation中提供的注解，源码如下：
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({MapperScannerRegistrar.class})
@Repeatable(MapperScans.class)
public @interface MapperScan {
String[] value() default {};
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
Class<? extends Annotation> annotationClass() default Annotation.class;
// ... ...
}
重点关注一下@Import({MapperScannerRegistrar.class})，当@MapperScan被扫描加载时，会解析@Import注解，从而加载指定的类，此处就是加载了MapperScannerRegistrar
MapperScannerRegistrar实现了ImportBeanDefinitionRegistrar接口，Spring会自动调用 registerBeanDefinitions方法，该方法中又注册MapperScannerConfigurer类，而MapperScannerConfigurer类 作用是扫描Mapper，向容器中注册Mapper对应的MapperFactoryBean
AOP
- AOP的概念
- AOP思想的实现方案
模拟AOP的基础代码
//自定义增强类
public class MyAdvice {
public void beforeAdvice(){
System.out.println("beforeAdvice ...");
}
public void afterAdvice(){
System.out.println("afterAdvice ...");
}
}public class MockAopBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {
private ApplicationContext applicationContext;//注入Spring容器对象
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
MyAdvice myAdvice = applicationContext.getBean(MyAdvice.class);//获得Advice对象
String packageName = bean.getClass().getPackage().getName();
if("com.itheima.service.impl".equals(packageName)){
//对Bean进行动态代理，返回的是Proxy代理对象
Object proxyBean = Proxy.newProxyInstance(
bean.getClass().getClassLoader(),
bean.getClass().getInterfaces(),
(Object proxy, Method method, Object[] args) -> {
myAdvice.beforeAdvice();//执行Advice的before方法
Object result = method.invoke(bean, args);//执行目标
myAdvice.afterAdvice();//执行Advice的after方法
return result; });
//返回代理对象
return proxyBean; }
return bean; }
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}}AOP相关概念
xml方式AOP快速入门
1、导入AOP相关坐标
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
2、准备目标类、准备增强类，并配置给Spring管理
3、配置切点表达式（哪些方法被增强）
4、配置织入（切点被哪些通知方法增强，是前置增强还是后置增强）
<aop:config>
<!--配置切点表达式,对哪些方法进行增强-->
<aop:pointcut id="myPointcut" expression="execution(void
com.itheima.service.impl.UserServiceImpl.show1())"/>
<!--切面=切点+通知-->
<aop:aspect ref="myAdvice">
<!--指定前置通知方法是beforeAdvice-->
<aop:before method="beforeAdvice" pointcut-ref="myPointcut"/>
<!--指定后置通知方法是afterAdvice-->
<aop:after-returning method="afterAdvice" pointcut-ref="myPointcut"/>
</aop:aspect>
</aop:config>xml方式AOP配置详解
<aop:config>
<!--配置切点表达式,对哪些方法进行增强-->
<aop:pointcut id="myPointcut" expression="execution(void
com.itheima.service.impl.UserServiceImpl.show1())"/>
<!--切面=切点+通知-->
<aop:aspect ref="myAdvice">
<!--指定前置通知方法是beforeAdvice-->
<aop:before method="beforeAdvice" pointcut-ref="myPointcut"/>
<!--指定后置通知方法是afterAdvice-->
<aop:after-returning method="afterAdvice" pointcut="execution(void
com.itheima.service.impl.UserServiceImpl.show1())"/>
</aop:aspect>
</aop:config>
切点表达式举几个例子方便理解
// 表示访问修饰符为 public 、无返回值、在 com.itheima.aop 包下的 TargetImpl 类的无参方法 showexecution(public void com.itheima.aop.TargetImpl.show())// 表述 com.itheima.aop 包下的 TargetImpl 类的任意方法execution(* com.itheima.aop.TargetImpl.*(..))// 表示 com.itheima.aop 包下的任意类的任意方法execution(* com.itheima.aop.*.*(..))// 表示 com.itheima.aop 包及其子包下的任意类的任意方法execution(* com.itheima.aop..*.*(..))// 表示任意包中的任意类的任意方法execution(* *..*.*(..))
AspectJ的通知由以下五种类型
通知方法在被调用时，Spring可以为其传递一些必要的参数
JoinPoint 对象
public void 通知方法名称(JoinPoint joinPoint){
//获得目标方法的参数
System.out.println(joinPoint.getArgs());
//获得目标对象
System.out.println(joinPoint.getTarget());
//获得精确的切点表达式信息
System.out.println(joinPoint.getStaticPart());
}ProceedingJoinPoint对象
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println(joinPoint.getArgs());//获得目标方法的参数
System.out.println(joinPoint.getTarget());//获得目标对象
System.out.println(joinPoint.getStaticPart());//获得精确的切点表达式信息
Object result = joinPoint.proceed();//执行目标方法
return result;//返回目标方法返回值
}
AOP的另一种配置方式，该方式需要通知类实现Advice的子功能接口
public interface Advice {
}
由于实际开发中，自定义aop功能的配置大多使用aspect的配置方式，所以我们后面主要讲解aspect的配置， advisor是为了后面Spring声明式事务控制做铺垫，此处大家了解即可。
xml方式AOP原理剖析
JDK的动态代理代码，之前已经写过了，下面看一下Cglib基于超类的动态代理
Target target = new Target();//目标对象
Advices advices = new Advices();//通知对象
Enhancer enhancer = new Enhancer();//增强器对象
enhancer.setSuperclass(Target.class);//增强器设置父类
//增强器设置回调
enhancer.setCallback((MethodInterceptor )(o, method, objects, methodProxy) -> {
advices.before();
Object result = method.invoke(target, objects);
advices.afterReturning();
return result;
});
//创建代理对象
Target targetProxy = (Target) enhancer.create();
//测试
String result = targetProxy.show("haohao");基于注解配置的AOP
<!--配置目标-->
<bean id="target" class="com.itheima.aop.TargetImpl"></bean>
<!--配置通知-->
<bean id="advices" class="com.itheima.aop.Advices"></bean>
<!--配置aop-->
<aop:config proxy-target-class="true">
<aop:aspect ref="advices">
<aop:around method="around" pointcut="execution(* com.itheima.aop.*.*(..))"/>
</aop:aspect>
</aop:config>@Component("target")
public class TargetImpl implements Target{
public void show() {
System.out.println("show Target running...");
}}
@Component
public class AnnoAdvice {
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕前通知...");
joinPoint.proceed();
System.out.println("环绕后通知...");
}}
注解@Aspect、@Around需要被Spring解析，所以在Spring核心配置文件中需要配置aspectj的自动代理
<aop:aspectj-autoproxy/>如果核心配置使用的是配置类的话，需要配置注解方式的aop自动代理
@Configuration
@ComponentScan("com.itheima.aop")
@EnableAspectJAutoProxy //第三步
public class ApplicationContextConfig {
}//前置通知
@Before("execution(* com.itheima.aop.*.*(..))")
public void before(JoinPoint joinPoint){}
//后置通知
@AfterReturning("execution(* com.itheima.aop.*.*(..))")
public void AfterReturning(JoinPoint joinPoint){}
//环绕通知
@Around("execution(* com.itheima.aop.*.*(..))")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {}
//异常通知
@AfterThrowing("execution(* com.itheima.aop.*.*(..))")
public void AfterThrowing(JoinPoint joinPoint){}
//最终通知
@After("execution(* com.itheima.aop.*.*(..))")
public void After(JoinPoint joinPoint){}@Component
@Aspect
public class AnnoAdvice {
//切点表达式抽取
@Pointcut("execution(* com.itheima.aop.*.*(..))")
public void pointcut(){}
//前置通知
@Before("pointcut()")
public void before(JoinPoint joinPoint){}
//后置通知
@AfterReturning("AnnoAdvice.pointcut()")
public void AfterReturning(JoinPoint joinPoint){}
// ... 省略其他代码 ...
}注解方式AOP原理剖析
this.registerBeanDefinitionParser("aspectj-autoproxy", new
AspectJAutoProxyBeanDefinitionParser());
如果使用的是核心配置类的话
@Configuration
@ComponentScan("com.itheima.aop")
@EnableAspectJAutoProxy
public class ApplicationContextConfig {
}查看@EnableAspectJAutoProxy源码，使用的也是@Import导入相关解析类
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
boolean proxyTargetClass() default false;
boolean exposeProxy() default false;
}public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
}
public static BeanDefinition
registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null);
}
public static BeanDefinition
registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable
Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class,
registry, source);
}
基于xml声明式事务控制 
基于注解声明式事务控制
注解就是对xml的替代
@Service("accountService")
public class AccoutServiceImpl implements AccountService {
@Autowired
private AccountMapper accountMapper;
//<tx:method name="*" isolation="REPEATABLE_READ" propagation="REQUIRED“/>
@Transactional(isolation = Isolation.REPEATABLE_READ,propagation =
Propagation.REQUIRED,readOnly = false,timeout = 5)
public void transferMoney(String decrAccountName, String incrAccountName, int money) {
accountMapper.decrMoney(decrAccountName,money); //转出钱
int i = 1/0; //模拟某些逻辑产生的异常
accountMapper.incrMoney(incrAccountName,money); //转入钱}}<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--配置事务的注解驱动-->
<tx:annotation-driven transaction-manager="transactionManager"/>@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@MapperScan("com.itheima.mapper")
@EnableTransactionManagement
public class SpringConfig {
@Bean
public DataSource dataSource(
@Value("${jdbc.driverClassName}") String driver,
@Value("${jdbc.url}") String url,
@Value("${jdbc.username}") String username,
@Value("${jdbc.password}") String password
){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
return sqlSessionFactoryBean;
}
@Bean
public DataSourceTransactionManager transactionManager(DataSource dataSource){
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}
Spring整合Web环境
Javaweb三大组件及环境特点
Spring整合web环境的思路及实现
Spring的web开发组件spring-web
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.7</version>
</dependency><context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>@WebServlet("/accountServlet")
public class AccountServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
ServletContext servletContext = request.getServletContext();
ApplicationContext applicationContext =
WebApplicationContextUtils.getWebApplicationContext(servletContext);
AccountService accountService = applicationContext.getBean(AccountService.class);
accountService.transferMoney("tom","lucy",500);}}public class MyAnnotationConfigWebApplicationContext extends
AnnotationConfigWebApplicationContext {
public MyAnnotationConfigWebApplicationContext(){
//注册核心配置类
super.register(ApplicationContextConfig.class);
}
}<context-param>
<param-name>contextClass</param-name>
<param-value>com.itheima.web.MyAnnotationConfigWebApplicationContext</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>MVC框架思想及其设计思路
负责共有行为的Servlet称之为前端控制器，负责业务行为的JavaBean称之为控制器Controller
SpringMVC
SpringMVC概述
SpringMVC是一个基于Spring开发的MVC轻量级框架，Spring3.0后发布的组件，SpringMVC和Spring可以无 缝整合，使用DispatcherServlet作为前端控制器，且内部提供了处理器映射器、处理器适配器、视图解析器等组 件，可以简化JavaBean封装，Json转化、文件上传等操作。
SpringMVC快速入门
导入Spring整合SpringMVC的坐标
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.7</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>编写一个控制器Controller，配置映射信息
@Controller
public class TestController {
@RequestMapping("/show")
public String show(){
System.out.println("show...");
return "/index.jsp";
}
}
在web.xml中配置SpringMVC的前端控制器DispatcherServlet
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--指定springMVC配置文件位置-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<!--服务器启动就创建-->
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
创建springMVC的核心配置文件 spring-mvc.xml，并配置组件扫描web层
<?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:mvc="http://www.springframework.org/schema/mvc"
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 组件扫描web层 -->
<context:component-scan base-package="com.itheima.controller"/>
</beans>
Controller中访问容器中的Bean
DispatcherServlet在进行初始化时，加载的spring-mvc.xml配置文件创建的SpringMVC容器，那么web层 Controller被扫描进入到了容器中，而之前Spring容器中的Service是否可以获取到呢？下面搭建Spring的web环 境进行验证
创建一个applicationContext.xml文件
<!-- 组件扫描非web层 -->
<context:component-scan base-package="com.itheima">
<!--排除com.itheima包下使用@Controller注解的类-->
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
在web.xml中配置ContextLoaderListener
<!--配置ContextLoaderListener-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applictionContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
编写UserService和UserServiceImp
public interface UserService {
public void show();}
@Service("userService")
public class UserServiceImpl implements UserService {
@Override
public void show() {
System.out.println("UserServiceImpl show running ... ...");
}}
修改UserController，从Spring容器中匹配Service进行注入
@Controller
public class UserController {
@Autowired
private UserService userService;
@RequestMapping("/show")
public String show(){
System.out.println("show 执行....");
//调用userService的show方法
userService.show();
//视图跳转到index.jsp
return "/index.jsp";
}
}
SpringMVC关键组件浅析
上面已经完成的快速入门的操作，也在不知不觉中完成的Spring和SpringMVC的整合，我们只需要按照规则去定 义Controller和业务方法就可以。但是在这个过程中，肯定是很多核心功能类参与到其中，这些核心功能类，一 般称为组件。当请求到达服务器时，是哪个组件接收的请求，是哪个组件帮我们找到的Controller，是哪个组件 帮我们调用的方法，又是哪个组件最终解析的视图？
先简单了解一下以上三个重要组件的关系
SpringMVC的默认组件，SpringMVC 在前端控制器 DispatcherServlet加载时，就会进行初始化操作，在进行初始 化时，就会加载SpringMVC默认指定的一些组件，这些默认组件配置在 DispatcherServlet.properties 文件中，该文 件存在与spring-webmvc-5.3.7.jar包下的 org\springframework\web\servlet\DispatcherServlet.properties
这些默认的组件是在DispatcherServlet中进行初始化加载的，在DispatcherServlet中存在集合存储着这些组件， SpringMVC的默认组件会在 DispatcherServlet 中进行维护，但是并没有存储在与SpringMVC的容器中
配置组件代替默认组件，如果不想使用默认组件，可以将替代方案使用Spring Bean的方式进行配置，例如，在 spring-mvc.xml中配置RequestMappingHandlerMapping
当我们在Spring容器中配置了HandlerMapping，则就不会在加载默认的HandlerMapping策略了，原理比较简单， DispatcherServlet 在进行HandlerMapping初始化时，先从SpringMVC容器中找是否存在HandlerMapping，如果 存在直接取出容器中的HandlerMapping，在存储到 DispatcherServlet 中的handlerMappings集合中去。
SpringMVC的请求处理
- 请求映射路径的配置
配置映射路径，映射器处理器才能找到Controller的方法资源，目前主流映射路径配置方式就是@RequestMapping
@RequestMapping注解，主要使用在控制器的方法上，用于标识客户端访问资源路径，常用的属性有value、path 、method、headers、params等。当@RequestMapping只有一个访问路径需要指定时，使用value属性、path属 性或省略value和path，当有多个属性时，value和path不能省略
@RequestMapping 在类上使用，@RequestMapping 、@GetMapping、@PostMapping还可以使用在 Controller类上，使用在类上后，该类所有方法都公用该@RequestMapping设置的属性，访问路径则为类上的映射 地址+方法上的映射地址，例如：
@Controller
@RequestMapping("/xxx")
public class UserController implements ApplicationContextAware, ServletContextAware {
@GetMapping("/aaa")
public ModelAndView aaa(HttpServletResponse response) throws IOException,
ModelAndViewDefiningException {
return null;
}
}此时的访问路径为：/xxx/aaa
请求数据的接收
配置完后，可以使用map接收json
接收Restful风格数据
什么是Rest风格？ Rest（Representational State Transfer）表象化状态转变（表述性状态转变），在2000年被提出，基于HTTP、URI 、xml、JSON等标准和协议，支持轻量级、跨平台、跨语言的架构设计。是Web服务的一种新网络应用程序的设计风 格和开发方式。
接收文件上传的数据，文件上传的表单需要一定的要求，如下：
Javaweb常用对象获取
获得Javaweb常见原生对象，有时在我们的Controller方法中需要用到Javaweb的原生对象，例如：Request、 Response等，我们只需要将需要的对象以形参的形式写在方法上，SpringMVC框架在调用Controller方法时，会自 动传递实参：
@GetMapping("/javawebObject")
public String javawebObject(HttpServletRequest request, HttpServletResponse response,
HttpSession session){
System.out.println(request);
System.out.println(response);
System.out.println(session);
return "/index.jsp";
}
请求静态资源
静态资源请求失效的原因，当DispatcherServlet的映射路径配置为 / 的时候，那么就覆盖的Tomcat容器默认的缺省 Servlet，在Tomcat的config目录下有一个web.xml 是对所有的web项目的全局配置，其中有如下配置：
<servlet>
<servlet-name>default</servlet-name>
<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>url-pattern配置为 / 的Servlet我们称其为缺省的Servlet，作用是当其他Servlet都匹配不成功时，就找缺省的Servlet ，静态资源由于没有匹配成功的Servlet，所以会找缺省的DefaultServlet，该DefaultServlet具备二次去匹配静态资 源的功能。但是我们配置DispatcherServlet后就将其覆盖掉了，而DispatcherServlet会将请求的静态资源的名称当 成Controller的映射路径去匹配，即静态资源访问不成功了！
静态资源请求的三种解决方案：
第一种方案，可以再次激活Tomcat的DefaultServlet，Servlet的url-pattern的匹配优先级是：精确匹配>目录匹配> 扩展名匹配>缺省匹配，所以可以指定某个目录下或某个扩展名的资源使用DefaultServlet进行解析：
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/img/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
第二种方式，在spring-mvc.xml中去配置静态资源映射，匹配映射路径的请求到指定的位置去匹配资源
<!-- mapping是映射资源路径，location是对应资源所在的位置 -->
<mvc:resources mapping="/img/*" location="/img/"/>
<mvc:resources mapping="/css/*" location="/css/"/>
<mvc:resources mapping="/css/*" location="/js/"/>
<mvc:resources mapping="/html/*" location="/html/"/>第三种方式，在spring-mvc.xml中去配置< mvc:default-servlet-handler >，该方式是注册了一个 DefaultServletHttpRequestHandler 处理器，静态资源的访问都由该处理器去处理，这也是开发中使用最多的
<mvc:default-servlet-handler/>
静态资源配置的第二第三种方式我们可以正常访问静态资源了，但是Controller又无法访问了，报错404，即找不到对应的资源
第二种方式是通过SpringMVC去解析mvc命名空间下的resources标签完成的静态资源解析，第三种方式式通过 SpringMVC去解析mvc命名空间下的default-servlet-handler标签完成的静态资源解析，根据前面所学习的自定义命 名空间的解析的知识，可以发现不管是以上哪种方式，最终都会注册SimpleUrlHandlerMapping
public BeanDefinition parse(Element element, ParserContext context) {
//创建SimpleUrlHandlerMapping类型的BeanDefinition
RootBeanDefinition handlerMappingDef =
new RootBeanDefinition(SimpleUrlHandlerMapping.class);
//注册SimpleUrlHandlerMapping的BeanDefinition
context.getRegistry().registerBeanDefinition(beanName, handlerMappingDef);
}
又结合组件浅析知识点，一旦SpringMVC容器中存在 HandlerMapping 类型的组件时，前端控制器 DispatcherServlet在进行初始化时，就会从容器中获得HandlerMapping ，不在加载 dispatcherServlet.properties 中默认处理器映射器策略，那也就意味着RequestMappingHandlerMapping不会被加载到了。
手动将RequestMappingHandlerMapping也注册到SpringMVC容器中就可以了，这样DispatcherServlet在进行初 始化时，就会从容器中同时获得RequestMappingHandlerMapping存储到DispatcherServlet中名为 handlerMappings的List集合中，对@RequestMapping 注解进行解析。
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
注解驱动 <mvc:annotation-driven/>标签
根据上面的讲解，可以总结一下，要想使用@RequestMapping正常映射到资源方法，同时静态资源还能正常访问， 还可以将请求json格式字符串和JavaBean之间自由转换，我们就需要在spring-mvc.xml中尽心如下配置：
<!-- 显示配置RequestMappingHandlerMapping -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
<!-- 显示配置RequestMappingHandlerAdapter -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
</list>
</property>
</bean>
<!--配置DefaultServletHttpRequestHandler-->
<mvc:default-servlet-handler/>
这么复杂繁琐的配置，是不是看上去有点头大？Spring是个"暖男"，将上述配置浓缩成了一个简单的配置标签，那就 是mvc的注解驱动，该标签内部会帮我们注册RequestMappingHandlerMapping、注册 RequestMappingHandlerAdapter并注入Json消息转换器等，上述配置就可以简化成如下：
<!--mvc注解驱动-->
<mvc:annotation-driven/>
<!--配置DefaultServletHttpRequestHandler-->
<mvc:default-servlet-handler/>PS： 标签在不同的版本中，帮我们注册的组件不同，Spring 3.0.X 版本注册是 DefaultAnnotationHandlerMapping 和 AnnotationMethodHandlerAdapter，由于框架的发展，从Spring 3.1.X 开始注册组件变为 RequestMappingHandlerMapping和RequestMappingHandlerAdapter
SpringMVC的响应处理
传统同步业务数据响应
Spring的接收请求的部分我们讲完了，下面在看一下Spring怎么给客户端响应数据，响应数据主要分为两大部分：
传统同步方式：准备好模型数据，在跳转到执行页面进行展示，此方式使用越来越少了，基于历史原因，一些旧 项目还在使用；
前后端分离异步方式：前端使用Ajax技术+Restful风格与服务端进行Json格式为主的数据交互，目前市场上几乎 都是此种方式了。
传统同步业务在数据响应时，SpringMVC又涉及如下四种形式：
请求资源转发；
请求资源重定向；
响应模型数据；
直接回写数据给客户端；
响应模型数据，响应模型数据本质也是转发，在转发时可以准备模型数据
@GetMapping("/forward5")
public ModelAndView forward5(ModelAndView modelAndView){
//准备JavaBean模型数据
User user = new User();
user.setUsername("haohao");
//设置模型
modelAndView.addObject("user",user);
//设置视图
modelAndView.setViewName("/index.jsp");
return modelAndView;
}
直接回写数据，直接通过方法的返回值返回给客户端的字符串，但是SpringMVC默认的方法返回值是视图，可以通过 @ResponseBody 注解显示的告知此处的返回值不要进行视图处理，是要以响应体的方式处理的
@GetMapping("/response2")
@ResponseBody
public String response2() throws IOException {
return "Hello haohao!";
}
前后端分离异步业务数据响应
其实此处的回写数据，跟上面回写数据给客户端的语法方式一样，只不过有如下一些区别：
同步方式回写数据，是将数据响应给浏览器进行页面展示的，而异步方式回写数据一般是回写给Ajax引擎的，即 谁访问服务器端，服务器端就将数据响应给谁
同步方式回写的数据，一般就是一些无特定格式的字符串，而异步方式回写的数据大多是Json格式字符串
回写普通数据使用@ResponseBody标注方法，直接返回字符串即可，此处不在说明； 回写Json格式的字符串，即将直接拼接Json格式的字符串或使用工具将JavaBean转换成Json格式的字符串回写
@GetMapping("/response3")
@ResponseBody
public String response3(HttpServletResponse response) {
return "{\"username\":\"haohao\",\"age\":18}";
}
@GetMapping("/response4")
@ResponseBody
public String response4() throws JsonProcessingException {
//创建JavaBean
User user = new User();
user.setUsername("haohao");
user.setAge(18);
//使用Jackson转换成json格式的字符串
String json = new ObjectMapper().writeValueAsString(user);
return json;
}
在讲解SringMVC接收请求数据时，客户端提交的Json格式的字符串，也是使用Jackson进行的手动转换成JavaBean ，可以当我们使用了@RequestBody时，直接用JavaBean就接收了Json格式的数据，原理其实就是SpringMVC底层 帮我们做了转换，此处@ResponseBody也可以将JavaBean自动给我们转换成Json格式字符串回响应
@GetMapping("/response5")
@ResponseBody
public User response5() throws JsonProcessingException {
//创建JavaBean
User user = new User();
user.setUsername("haohao");
user.setAge(18);
//直接返回User对象
return user;
}
@ResponseBody注解使用优化，在进行前后端分离开发时，Controller的每个方法都是直接回写数据的，所以每个 方法上都得写@ResponseBody，可以将@ResponseBody写到Controller上，那么该Controller中的所有方法都具备 了返回响应体数据的功能了
进一步优化，可以使用@RestController替代@Controller和@ResponseBody，@RestController内部具备的这两个 注解的功能
SpringMVC的拦截器
拦截器 Interceptor 简介
SpringMVC的拦截器Interceptor规范，主要是对Controller资源访问时进行拦截操作的技术，当然拦截后可以进行权 限控制，功能增强等都是可以的。拦截器有点类似 Javaweb 开发中的Filter，拦截器与Filter的区别如下图：
由上图，对Filter 和 Interceptor 做个对比：
实现了HandlerInterceptor接口，且被Spring管理的Bean都是拦截器，接口定义如下：
public interface HandlerInterceptor {
default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object
handler) throws Exception {
return true;
}
default void postHandle(HttpServletRequest request, HttpServletResponse response, Object
handler, @Nullable ModelAndView modelAndView) throws Exception {
}
default void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, @Nullable Exception ex) throws Exception {
}
}
HandlerInterceptor接口方法的作用及其参数、返回值详解如下：
拦截器快速入门
编写MyInterceptor01实现HandlerInterceptor接口：
public class MyInterceptor01 implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object
handler) throws Exception {
System.out.println("Controller方法执行之前...");
return true;//放行
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("Controller方法执行之后...");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object
handler, Exception ex) throws Exception {
System.out.println("渲染视图结束，整个流程完毕...");
}
}配置Interceptor
<!--配置拦截器-->
<mvc:interceptors>
<mvc:interceptor>
<!--配置对哪些资源进行拦截操作-->
<mvc:mapping path=“/**"/>
<bean class="com.itheima.interceptor.MyInterceptor01"></bean>
</mvc:interceptor>
</mvc:interceptors>拦截器执行顺序
当Interceptor1和Interceptor2处于放行，Interceptor3处于不放行时，三个方法的执行顺序如下：
拦截器执行顺序取决于 interceptor 的配置顺序
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/target"/>
<bean class="com.itheima.interceptor.MyInterceptor02"></bean>
</mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/*"/>
<bean class="com.itheima.interceptor.MyInterceptor01"></bean>
</mvc:interceptor>
</mvc:interceptors>拦截器执行原理
public class HandlerExecutionChain {
//映射的Controller的方法
private final Object handler;
//当前Handler匹配的拦截器集合
private final List<HandlerInterceptor> interceptorList;
// ... 省略其他代码 ...
}protected void doDispatch(HttpServletRequest request, HttpServletResponse response){
//根据请求信息获得HandlerExecutionChain
HandlerExecutionChain mappedHandler = this.getHandler(request);
//获得处理器适配器
HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
//执行Interceptor的前置方法，前置方法如果返回false，则该流程结束
if (!mappedHandler.applyPreHandle(request, response)) {
return;
}
//执行handler，一般是HandlerMethod
ModelAndView mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
//执行后置方法
mappedHandler.applyPostHandle(processedRequest, response, mv);
//执行最终方法
this.triggerAfterCompletion(processedRequest, response, mappedHandler, e);
}boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws
Exception {
//对interceptorList进行遍历,正向遍历,与此同时使用interceptorIndex进行计数
for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
//取出每一个Interceptor对象
HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
//调用Interceptor的preHandle方法，如果返回false，则直接执行Interceptor的最终方法
if (!interceptor.preHandle(request, response, this.handler)) {
//执行Interceptor的最终方法
this.triggerAfterCompletion(request, response, (Exception)null);
return false;
}
}
return true;
}void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable
ModelAndView mv) throws Exception {
//对interceptorList进行遍历，逆向遍历
for(int i = this.interceptorList.size() - 1; i >= 0; --i) {
//取出每一个Interceptor
HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
//执行Interceptor的postHandle方法
interceptor.postHandle(request, response, this.handler, mv);
}
}void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable
Exception ex) {
//逆向遍历interceptorList，遍历的个数为执行的applyPreHandle次数-1
for(int i = this.interceptorIndex; i >= 0; --i) {
//取出每一个Interceptor
HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
try {
//执行Interceptor的afterCompletion方法
interceptor.afterCompletion(request, response, this.handler, ex);
} catch (Throwable var7) {
logger.error("HandlerInterceptor.afterCompletion threw exception", var7);
}
}
}
SpringMVC的全注解开发
spring-mvc.xml 中组件转化为注解形式
<!-- 组件扫描web层 -->
<context:component-scan base-package="com.itheima.controller"/>
<!--注解驱动-->
<mvc:annotation-driven/>
<!--配置文件上传解析器-->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/>
<!--配置拦截器-->
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/*"/>
<bean class="com.itheima.interceptor.MyInterceptor01"></bean>
</mvc:interceptor>
</mvc:interceptors>
<!--配置DefaultServletHttpRequestHandler-->
<mvc:default-servlet-handler/>@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMVCConfig {
@Bean
public CommonsMultipartResolver multipartResolver(){
CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
multipartResolver.setDefaultEncoding("UTF-8");
multipartResolver.setMaxUploadSize(3145728);
multipartResolver.setMaxUploadSizePerFile(1048576);
multipartResolver.setMaxInMemorySize(1048576);
return multipartResolver;
}
}@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {}@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
//从容器中注入WebMvcConfigurer类型的Bean
@Autowired(required = false)
public void setConfigurers(List<WebMvcConfigurer> configurers) {
if (!CollectionUtils.isEmpty(configurers)) {
this.configurers.addWebMvcConfigurers(configurers);
}}
//省略其他代码}public interface WebMvcConfigurer {
//配置默认Servet处理器
default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { }
//添加拦截器
default void addInterceptors(InterceptorRegistry registry) { }
//添加资源处理器
default void addResourceHandlers(ResourceHandlerRegistry registry) { }
//添加视图控制器
default void addViewControllers(ViewControllerRegistry registry) { }
//配置视图解析器
default void configureViewResolvers(ViewResolverRegistry registry) { }
//添加参数解析器
default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) { }
//... 省略其他代码 ...
}
高级软件人才培训专家@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
//开启DefaultServlet，可以处理静态资源了
configurer.enable();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
//创建拦截器对象，进行注册
//Interceptor的执行顺序也取决于添加顺序
registry.addInterceptor(new MyInterceptor01()).addPathPatterns("/*");
}
}@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc
public class SpringMVCConfig {
@Bean
public CommonsMultipartResolver multipartResolver(){
CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
multipartResolver.setDefaultEncoding("UTF-8");
multipartResolver.setMaxUploadSize(3145728);
multipartResolver.setMaxUploadSizePerFile(1048576);
multipartResolver.setMaxInMemorySize(1048576);
return multipartResolver;
}
}DispatcherServlet加载核心配置类
<!--配置springMVC前端控制器-->
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--指定springMVC配置文件位置-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<!--服务器启动就创建-->
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>public class MyAnnotationConfigWebApplicationContext extends
AnnotationConfigWebApplicationContext {
public MyAnnotationConfigWebApplicationContext(){
//注册核心配置类
super.register(SpringMVCConfig.class);
}
}<!--指定springMVC的applicationContext全限定名 -->
<init-param>
<param-name>contextClass</param-name>
<param-value>com.itheima.config.MyAnnotationConfigWebApplicationContext</param-value>
</init-param>消除web.xml
<!--配置springMVC前端控制器-->
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--指定springMVC的applicationContext全限定名 -->
<init-param>
<param-name>contextClass</param-name>
<param-value>com.itheima.config.MyAnnotationConfigWebApplicationContext</param-value>
</init-param>
<!--服务器启动就创建-->
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
按照下面的配置就可以完全省略web.xml
public class MyAnnotationConfigDispatcherServletInitializer extends
AbstractAnnotationConfigDispatcherServletInitializer {
//返回的带有@Configuration注解的类用来配置ContextLoaderListener
protected Class<?>[] getRootConfigClasses() {
System.out.println("加载核心配置类创建ContextLoaderListener");
return new Class[]{ApplicationContextConfig.class};
}
//返回的带有@Configuration注解的类用来配置DispatcherServlet
protected Class<?>[] getServletConfigClasses() {
System.out.println("加载核心配置类创建DispatcherServlet");
return new Class[]{SpringMVCConfig.class};
}
//将一个或多个路径映射到DispatcherServlet上
protected String[] getServletMappings() {
return new String[]{"/"};
}
}SpringMVC的组件原理剖析
前端控制器初始化
HttpServletBean 的初始化方法
public final void init() throws ServletException {
this.initServletBean();
}protected final void initServletBean() throws ServletException {
this.webApplicationContext = this.initWebApplicationContext();//初始化ApplicationContext
this.initFrameworkServlet();//模板设计模式，供子类覆盖实现，但是子类DispatcherServlet没做使用
}//初始化ApplicationContext是一个及其关键的代码
protected WebApplicationContext initWebApplicationContext() {
//获得根容器，其实就是通过ContextLoaderListener创建的ApplicationContext
//如果配置了ContextLoaderListener则获得根容器，没配置获得的是null
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
//定义SpringMVC产生的ApplicationContext子容器
WebApplicationContext wac = null;
if (wac == null) {
//==>创建SpringMVC的子容器，创建同时将Spring的创建的rootContext传递了过去
wac = this.createWebApplicationContext(rootContext);
}
//将SpringMVC产生的ApplicationContext子容器存储到ServletContext域中
//key名是：org.springframework.web.servlet.FrameworkServlet.CONTEXT.DispatcherServlet
if (this.publishContext) {
String attrName = this.getServletContextAttributeName();
this.getServletContext().setAttribute(attrName, wac);
}}protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext
parent) {
//实例化子容器ApplicationContext
ConfigurableWebApplicationContext wac =
(ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
//设置传递过来的ContextLoaderListener的rootContext为父容器
wac.setParent(parent);
//获得web.xml配置的classpath:spring-mvc.xml
String configLocation = this.getContextConfigLocation();
if (configLocation != null) {
//为子容器设置配置加载路径
wac.setConfigLocation(configLocation);
}
//初始化子容器(就是加载spring-mvc.xml配置的Bean)
this.configureAndRefreshWebApplicationContext(wac);
return wac;
}
父容器和子容器概念和关系：
//DispatcherServlet初始化SpringMVC九大组件
protected void initStrategies(ApplicationContext context) {
this.initMultipartResolver(context);//1、初始化文件上传解析器
this.initLocaleResolver(context);//2、初始化国际化解析器
this.initThemeResolver(context);//3、初始化模板解析器
this.initHandlerMappings(context);//4、初始化处理器映射器
this.initHandlerAdapters(context);//5、初始化处理器适配器
this.initHandlerExceptionResolvers(context);//6、初始化处理器异常解析器
this.initRequestToViewNameTranslator(context);//7、初始化请求视图转换器
this.initViewResolvers(context);//8、初始化视图解析器
this.initFlashMapManager(context);//9、初始化lashMapManager策略组件
}//定义List容器存储HandlerMapping
private List<HandlerMapping> handlerMappings;
//初始化HandlerMapping的方法
private void initHandlerMappings(ApplicationContext context) {
this.handlerMappings = null;//初始化集合为null
//detectAllHandlerMappings默认为true，代表是否从所有容器中(父子容器)检测HandlerMapping
if (this.detectAllHandlerMappings) {
//从Spring容器中去匹配HandlerMapping
Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context,
HandlerMapping.class, true, false);
//如果从容器中获取的HandlerMapping不为null就加入到事先定义好的handlerMappings容器中
if (!matchingBeans.isEmpty()) {
this.handlerMappings = new ArrayList(matchingBeans.values());
AnnotationAwareOrderComparator.sort(this.handlerMappings);
}
//如果从容器中没有获得HandlerMapping，意味着handlerMappings集合是空的
if (this.handlerMappings == null) {
//加载默认的HandlerMapping，就是加载DispatcherServlet.properties文件中的键值对
this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class);
} } }
前端控制器执行主流程
protected final void processRequest(HttpServletRequest request, HttpServletResponse response){
this.doService(request, response);
}protected void doService(HttpServletRequest request, HttpServletResponse response) {
this.doDispatch(request, response);
}protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null; //定义处理器执行链对象
ModelAndView mv = null; //定义模型视图对象
//匹配处理器映射器HandlerMapping，返回处理器执行链对象
mappedHandler = this.getHandler(processedRequest);
//匹配处理器适配器HandlerAdapter，返回处理器适配器对象
HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
//执行Interceptor的前置方法preHandle
mappedHandler.applyPreHandle(processedRequest, response);
//处理器适配器执行控制器Handler，返回模型视图对象
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
//执行Interceptor的后置方法postHandle
mappedHandler.applyPostHandle(processedRequest, response, mv);
//获取视图渲染视图
this.processDispatchResult(processedRequest, response, mappedHandler, mv,
(Exception)dispatchException);
}SpringMvc异常处理机制
SpringMvc异常处理流程
异常分为编译时异常和运行时异常，编译时异常我们 try-cache 进行捕获，捕获后自行处理，而运行时异常是不 可预期的，就需要规范编码来避免，在SpringMVC 中，不管是编译异常还是运行时异常，都可以最终由 SpringMVC提供的异常处理器进行统一处理，这样就避免了随时随地捕获处理的繁琐性。
当然除了繁琐之外，我们在进行前后端分离异步开发时，往往返回统一格式的结果给客户端，例如： {"code":200,"message":"","data":{"username":"haohao","age":null}}，即使报异常了，也不能把状态码500直 接扔给客户端丢给用户，需要将异常转换成符合上面格式的数据响应给客户端更友好。
SpringMVC 处理异常的思路是，一路向上抛，都抛给前端控制器 DispatcherServlet ，DispatcherServlet 在调 用异常处理器ExceptionResolver进行处理，如下图:
SpringMVC 的异常处理方式
SpringMVC 提供了以下三种处理异常的方式：
简单异常处理器：使用SpringMVC 内置的异常处理器处理 SimpleMappingExceptionResolver；
自定义异常处理器：实现HandlerExceptionResolver接口，自定义异常进行处理；
注解方式：使用@ControllerAdvice + @ExceptionHandler 来处理
使用SimpleMappingExceptionResolver处理一些简单异常，配置开启SimpleMappingExceptionResolver， 并指定异常捕获后的处理动作，当发生了异常后，会被 SimpleMappingExceptionResolver 处理，跳转到我们 配置的错误页面error.html给用户进行友好展示
@Bean
public SimpleMappingExceptionResolver simpleMappingExceptionResolver(){
//创建SimpleMappingExceptionResolver
SimpleMappingExceptionResolver resolver = new SimpleMappingExceptionResolver();
//设置默认错误展示视图
resolver.setDefaultErrorView("/error.html");
//定义Properties设置特殊异常对应的映射视图
Properties properties = new Properties();
properties.setProperty("java.lang.RuntimeException","/error.html");
properties.setProperty("java.io.FileNotFoundException","/io.html");
resolver.setExceptionMappings(properties);
return resolver;
}
自定义异常处理器，实现HandlerExceptionResolver接口自定义异常处理器，可以完成异常逻辑的处理
@Component
public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse, Object o, Exception e) {
//编写要返回的json格式的字符串
String jsonStr = "{\"code\":0,\"message\":\"error\",\"data\":\"\"}";
try {
httpServletResponse.getWriter().write(jsonStr);
} catch (IOException e1) {
e1.printStackTrace();
}
return null;
}
}
使用注解 @ControllerAdvice + @ExceptionHandler 配置异常，@ControllerAdvice 注解本质是一个 @Component，也会被扫描到，与此同时，具备AOP功能，默认情况下对所有的Controller都进行拦截操作， 拦截后干什么呢？就需要在结合@ExceptionHandler、@InitBinder、@ModelAttribute 注解一起使用了，此 处我们讲解的是异常，所以是@ControllerAdvice + @ExceptionHandler的组合形式。
编写全局异常处理器类，使用@ControllerAdvice标注，且@ExceptionHandler指定异常类型
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(RuntimeException.class)
public ModelAndView runtimeHandleException(RuntimeException e){
System.out.println("全局异常处理器执行...."+e);
ModelAndView modelAndView = new ModelAndView("/error.html");
return modelAndView;
}
@ExceptionHandler(IOException.class)
@ResponseBody
public ResultInfo ioHandleException(IOException e){
//模拟一个ResultInfo
ResultInfo resultInfo = new ResultInfo(0,"IOException",null);
return resultInfo;
}
}
如果全局异常处理器响应的数据都是Json格式的字符串的话，可以使用@RestControllerAdvice替代 @ControllerAdvice 和 @ResponseBody
异常处理机制原理剖析
初始化加载的处理器异常解析器，SpringMVC 的前置控制器在进行初始化的时候，会初始化处理器异常解析器 HandlerExceptionResolver
加载DispatcherServlet.properties中默认的异常处理器
异常处理器加载完毕后，当发生异常时，就会进行处理，跟踪 DispatcherServlet 的 doDispatch() 方法
跟踪processDispatchResult方法
跟踪processHandlerException 方法
SpringMVC 常用的异常解析器
SpringMVC 相关的处理器异常解析器继承体系如下
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
