Spring框架总结【无比详细】

Love The Way You Lie 2022-02-19 23:51 219阅读 0赞

链接：[https://blog.csdn.net/itcats\_cn/article/details/81479185][https_blog.csdn.net_itcats_cn_article_details_81479185]

**一、IOC和DI**  
spring注入方式

**第一种：配置文件方式注入：**

编写两个学生类和教师类：

package com.wajpzywj.vo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    
    public class Student { 
    	
    	private String stuName;
    	
    	private int stuAge;
    	
    	private Teacher teacher;
    	
    	public Student() { 
    		super();
    	}
    
    	public Student(String stuName, int stuAge, Teacher teacher) { 
    		super();
    		this.stuName = stuName;
    		this.stuAge = stuAge;
    		this.teacher = teacher;
    	}
    
    	public String getStuName() { 
    		return stuName;
    	}
    
    	public void setStuName(String stuName) { 
    		this.stuName = stuName;
    	}
    
    	public int getStuAge() { 
    		return stuAge;
    	}
    
    	public void setStuAge(int stuAge) { 
    		this.stuAge = stuAge;
    	}
    
    	public Teacher getTeacher() { 
    		return teacher;
    	}
    
    	public void setTeacher(Teacher teacher) { 
    		this.teacher = teacher;
    	}
    
    	@Override
    	public String toString() { 
    		return "Student [stuName=" + stuName + ", stuAge=" + stuAge + ", teacher=" + teacher + "]";
    	}
    	
    	
    
    }

package com.wajpzywj.vo;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    
    public class Teacher { 
    	
    	private int teAge;
    	
    	private String teName;
    	
    	public int getTeAge() { 
    		return teAge;
    	}
    	public void setTeAge(int teAge) { 
    		this.teAge = teAge;
    	}
    	public String getTeName() { 
    		return teName;
    	}
    	public void setTeName(String teName) { 
    		this.teName = teName;
    	}
    	@Override
    	public String toString() { 
    		return "Teacher [teAge=" + teAge + ", teName=" + teName + "]";
    	}
    	
    	
    	
    }

编写测试类：

package com.wajpzywj.test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.wajpzywj.service.IStudentService;
    import com.wajpzywj.vo.AllCollectionType;
    import com.wajpzywj.vo.Student;
    
    public class Test { 
    	public static void main(String[] args) { 
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		Student student = (Student) context.getBean("student");
    		System.out.println(student);
    	}
    
    }

(1)set方式注入(重点)————值类型用value注入 引用类型用ref注入

<bean id="student" class="com.wajpzywj.vo.Student">
    		
    		<property name="stuName" value="ls"></property>
    		<property name="stuAge" value="12"></property>
    		
    		<property name="teacher" ref="teacher"></property>
    </bean>
    
    <bean id="teacher" class="com.wajpzywj.vo.Teacher">
    		<property name="teAge" value="55"></property>
    		<property name="teName" value="xiaohongshu"></property>
    </bean>

(2)构造方法注入:实体类中要有相应的构造方法，

属性有：name,value,type,index  
type是该属性的类型，index是索引，为了能够进行准确匹配，可以省略。

<bean id="student" class="com.wajpzywj.vo.Student">
    		<constructor-arg name="stuName" value="ls"></constructor-arg>
    		<constructor-arg name="stuAge" value="25"></constructor-arg>
    		<constructor-arg name="teacher" ref="teacher"></constructor-arg>
    </bean>

(3) p名称空间注入———实际上set注入，spring特有，为了简化写法

1、applicationContext.xml中标签头部导入p命名空间

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

2、书写格式：值类型注入—— p:属性名=“值” 引用类型注入—— p:属性名-ref=“引用的 name属性”

<bean id="student" class="com.wajpzywj.vo.Student" p:stuName="zs" p:stuAge="34" p:teacher-ref="teacher"></bean>

(4)spel注入: spring Expression Language spring表达式语言

<bean id="student" class="com.wajpzywj.vo.Student">
    		<property name="stuName" value="#{teacher.teName}"></property>
    		<property name="stuAge" value="#{teacher.teAge}"></property>
    		<property name="teacher" ref="teacher"></property>
    </bean>

SpEL特性：(1)、使用Bean的ID来引用Bean；(2)、调用方法和访问对象的属性；(3)、对值进行算术、关系和逻辑运算；(4)、正则表达式匹配；(5)、集合操作  
关于spel [https://www.cnblogs.com/goodcheap/p/6490896.html][https_www.cnblogs.com_goodcheap_p_6490896.html]

**复杂类型注入\[重点\]**  
编写实体类AllCollectionType:

package com.wajpzywj.vo;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
    
    public class AllCollectionType { 
    	
    	private List<String> list;
    	
    	private String[] array;
    	
    	private Set<String> set;
    	
    	private Map<String,String> map;
    	
    	private Properties props;
    
    	public List<String> getList() { 
    		return list;
    	}
    
    	public void setList(List<String> list) { 
    		this.list = list;
    	}
    
    	public String[] getArray() { 
    		return array;
    	}
    
    	public void setArray(String[] array) { 
    		this.array = array;
    	}
    
    	public Set<String> getSet() { 
    		return set;
    	}
    
    	public void setSet(Set<String> set) { 
    		this.set = set;
    	}
    
    	public Map<String, String> getMap() { 
    		return map;
    	}
    
    	public void setMap(Map<String, String> map) { 
    		this.map = map;
    	}
    
    	public Properties getProps() { 
    		return props;
    	}
    
    	public void setProps(Properties props) { 
    		this.props = props;
    	}
    
    	@Override
    	public String toString() { 
    		String strContent = null;
    		for(String str : array) { 
    			strContent += str + ",";
    		}
    		
    		return "AllCollectionType [list=\n" + this.list + "\n, array=" 
    		+ Arrays.toString(this.array) + ", set=" + this.set + "\n, map=" + this.map
    				+ "\n, props=" + this.props + "]";
    	}
    }

bean配置：包含list, array, set, map, props

<bean id="collection" class="com.wajpzywj.vo.AllCollectionType">
    		<property name="list">
    			<list>
    				<value>足球list</value>
    				<value>篮球list</value>
    				<value>乒乓球list</value>
    			</list>
    		</property>
    		<property name="array">
    			<array>
    				<value>足球array</value>
    				<value>篮球array</value>
    				<value>乒乓球array</value>
    			</array>
    		</property>
    		<property name="set">
    			<set>
    				<value>足球set</value>
    				<value>篮球set</value>
    				<value>乒乓球set</value>
    			</set>
    		</property>
    		<property name="map">
    			<map>
    				<entry key="fot" value="足球"></entry>
    				<entry key="bas" value="篮球"></entry>
    				<entry key="ppq" value="乒乓球"></entry>
    			</map>
    		</property>
    		<property name="props">
    			<props>
    				<prop key="footttt">足球求</prop>
    				<prop key="baset1">蓝色球</prop>
    				<prop key="pppqiu">频频球</prop>
    			</props>
    		</property>
    </bean>

修改测试类：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    AllCollectionType collection = (AllCollectionType) context.getBean("collection");
    System.out.println(collection);

**【自动装配】：有的实体类的有些属性不用手动写，需要一个属性自动装配，系统会默认查找，内部自动添加**

修改学生类的bean, 少写了teacher属性，添加autowire属性，可以是byName, byType

<bean id="student" class="com.wajpzywj.vo.Student" autowire="byName">
    		<property name="stuName" value="ls"></property>
    		<property name="stuAge" value="12"></property>
    </bean>

*注意：autowire=“byName” 本质是byId  
byId：course类中有一个ref属性teacher（属性名），并且该ioc容器中恰好有一个bean的id也是teacher，bean的id值=类的属性名*

可以在头文件中，一次性将该ioc容器的所有bean 统一设置成自动装配

**缺点：自动装配虽然可以减少代码量，但是会降低程序的可读性，使用时需要谨慎。**

**第二种、使用注解方式代替配置文件(官方推荐使用注解)**

1.在applicationContext.xml中书写指定扫描注解

<context:component-scan base-package="com.wajpzywj.vo"></context:component-scan>

2.在类中书写Component(“student”)

// 相当于`<bean id="student" class="com.wajpzywj.vo.Student"></bean>`  
@Component(“student”)

可以细化成：  
@Repository dao层注解  
@Service service层注解  
@Controller 控制层注解

注意：假如不写括号内的值(即name或id)，默认使用类名首字母小写作为搜索，为什么意思呢？

比如Student类中使用了@Component 没有书写括号和值，那么默认搜索id或name为student。

3.指定对象的作用范围Scope  
![在这里插入图片描述][20190412092401574.png] 详解：[https://blog.csdn.net/itcats\_cn/article/details/81479185][https_blog.csdn.net_itcats_cn_article_details_81479185]

4.值类型的注入  
实际通过反射field赋值

// 学生类
    @Value("tom")
    private String stuName;
    @Value("22")
    private int stuAge;
    @Autowired
    private Teacher teacher;
    // 老师类
    @Value("88")
    private int teAge;
    @Value("ma")
    private String teName;

5.引用类型的注入

面试题: @AutoWired和@Resource的区别?

@AutoWired默认以类型进行查找，@Resource默认以名称进行查找

@AutoWired(required=false) + @Qualifier(“user”) == @Resource(name=“user”)

其中@Resource注解是jdk1.6后才有的  
![在这里插入图片描述][20190412091744943.png]  
6.创建与销毁方法

@PostConstruct //在对象被创建后调用。 init-method
    public void init() { 
    	System.out.println("初始化方法");
    }
    @PreDestroy //在销毁之前调用。destory-method
    public void destory() { 
    	System.out.println("销毁方法");
    }

7.spring整合junit测试(spring创建容器)

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70]  
**二、AOP**

1.  引入jar包  
    aopaliance.jar  
    aspectjweaver.jar
2.  准备目标对象(被代理对象，被通知的对象，被增强的类对象)

**注意：该实例通知使用了接口，如果不使用接口，aop实例参考：** [https://blog.csdn.net/itcats\_cn/article/details/81479185][https_blog.csdn.net_itcats_cn_article_details_81479185]

package com.wajpzywj.service.impl;
    
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import com.wajpzywj.dao.IStudentDao;
    import com.wajpzywj.dao.impl.StudentDaoImpl;
    import com.wajpzywj.service.IStudentService;
    import com.wajpzywj.vo.Student;
    
    public class StudentServiceImpl implements IStudentService{ 
    	
    	IStudentDao studentDao;
    	
    	
    	public IStudentDao getStudentDao() { 
    		return studentDao;
    	}
    
    
    	public void setStudentDao(IStudentDao studentDao) { 
    		this.studentDao = studentDao;
    	}
    
    // @Transactional(readOnly=false,propagation=Propagation.REQUIRED)
    	@Override
    	public void addStudent(Student student) { 
    		studentDao = null; //测试异常通知
    		studentDao.addStudent(student);
    	}
    
    
    	@Override
    	public void deleteStudent(Student student) { 
    		System.out.println("删除学生");
    	}
    	
    
    }

1.  准备通知(被增强方法的代码，想要实现功能的方法代码)

package com.wajpzywj.aop;
    
    import java.lang.reflect.Method;
    
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    import org.springframework.aop.AfterReturningAdvice;
    import org.springframework.aop.MethodBeforeAdvice;
    import org.springframework.aop.ThrowsAdvice;
    
    public class Log implements MethodBeforeAdvice,AfterReturningAdvice,ThrowsAdvice,MethodInterceptor{ 
    
    	public void afterThrowing(Method method, Object[] args,Object target,Throwable ex) { 
    		System.out.println("异常通知：目标对象："+target+",方法名："+method.getName()+",方法的参数："+args.length+"，异常类型："+ex.getMessage());
    	}
    	
    	@Override
    	public void before(Method method, Object[] args, Object target) throws Throwable { 
    		// TODO Auto-generated method stub
    		System.out.println("前置通知");
    	}
    
    	@Override
    	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { 
    		// TODO Auto-generated method stub
    		System.out.println("后置通知");
    	}
    
    	@Override
    	public Object invoke(MethodInvocation invocation) throws Throwable { 
    		//方法体1
    		Object result = null;
    		try { 
    			//方法体2
    			// invocation.proceed()之前的代码：前置通知
    			System.out.println("用环绕通知的前置通知");
    			System.out.println("环绕通知：目标对象："+invocation.getThis()+",方法名："+invocation.getMethod().getName()+",方法的参数："+invocation.getArguments().length+"，返回值类型："+result);
    			result = invocation.proceed();// 控制着目标方法的执行，addStudent()
    			// result 就是目标方法addStudent()方法的返回值
    			// invocation.proceed()之后的代码：后置通知
    			System.out.println("用环绕通知的后置通知");
    		} catch (Exception e) { 
    			//方法体3
    			System.out.println("用环绕通知的异常通知");
    		}
    		
    		
    		return result;
    	}
    	
    }

1.  配置 applicationContext.xml  
    1. 导入aop(约束)命名空间  
    2. 配置目标对象  
    3. 配置通知对象  
    4. 配置将通知织入目标对象

<bean id="studentService" class="com.wajpzywj.service.impl.StudentServiceImpl">
    	<property name="studentDao" ref="studentDao"></property>
    </bean>
    <bean id="studentDao" class="com.wajpzywj.dao.impl.StudentDaoImpl"></bean>
    
    
    <bean id="log" class="com.wajpzywj.aop.Log"></bean>
    
    <aop:config>
    	
    	<aop:pointcut expression="execution(public void com.wajpzywj.service.impl.StudentServiceImpl.addStudent(com.wajpzywj.vo.Student)) or execution(public void com.wajpzywj.service.impl.StudentServiceImpl.deleteStudent(com.wajpzywj.vo.Student))" id="pointcup"/>
    	
    	<aop:advisor advice-ref="log" pointcut-ref="pointcup"/>
    </aop:config>

1.  测试

package com.wajpzywj.test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.wajpzywj.service.IStudentService;
    import com.wajpzywj.vo.AllCollectionType;
    import com.wajpzywj.vo.Student;
    
    public class Test { 
    	public static void main(String[] args) { 
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		IStudentService studentService = (IStudentService) context.getBean("studentService");
    		Student stu = new Student();
    		stu.setStuName("aa");
    		stu.setStuAge(33);
    		
    		studentService.addStudent(stu);
    // studentService.deleteStudent(student);
    	}
    
    }

总结：通知的几种类型

> 1.前置通知———目标方法运行之前调用  
> 2.后置通知———目标方法运行之后调用(如果出现异常不调用)  
> 3.环绕通知———目标方法之前和之后都调用  
> 4.异常拦截通知———如果出现异常，就会调用  
> 5.后置通知———目标方法运行之后调用(无论是否出现异常都会调用)

**注意点：**

> 1.  异常通知： 根据异常通知接口的定义可以发现，异常通知的实现类 必须编写以下方法： public void afterThrowing(\[Method,args,target\], ThrowableSubclass):  
>     a. **public void afterThrowing(Method,args,target, ThrowableSubclass):**  
>     b. **public void afterThrowing(ThrowableSubclass):**
> 2.  环绕通知时，目标方法 的一切信息，都可以通过invocation参数获取到，底层是通过拦截器实现的

**aop使用注解配置**

1.  applicationContext.xml中配置目标对象，通知对象，
2.  开启使用注解完成织入
3.  配置扫描器
4.  @Aspect注解代表该类是个通知类，书写切点表达式@Pointcut(“execution(返回值 全类名.方法名(参数))”)

<bean id="studentService" class="com.wajpzywj.service.impl.StudentServiceImpl">
    	<property name="studentDao" ref="studentDao"></property>
    </bean>
    <bean id="studentDao" class="com.wajpzywj.dao.impl.StudentDaoImpl"></bean>
    
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    <context:component-scan base-package="com.wajpzywj.aop"></context:component-scan>

package com.wajpzywj.aop;
    
    import java.util.Arrays;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.springframework.stereotype.Component;
    @Component("logAnnotation")
    @Aspect //声明该类是一个通知
    public class LogAnnotation { 
    	
    	@Before("execution(public * addStudent(com.wajpzywj.vo.Student))") //属性：定义切点
    	public void myBefore(JoinPoint jp) { 
    		System.out.println("注解-----前置方法:目标对象："+jp.getTarget()
    		+",方法："+jp.getSignature().getName()+",参数列表："+Arrays.toString(jp.getArgs()));
    	}
    	
    	@AfterReturning(pointcut="execution(public * addStudent(com.wajpzywj.vo.Student))",returning = "returningValue")
    	public void myAfterReturn(JoinPoint jp,Object returningValue) { 
    		System.out.println("注解-----后置方法:目标对象："+jp.getTarget()
    		+",方法："+jp.getSignature().getName()+",参数列表："+Arrays.toString(jp.getArgs())+"，返回值："+returningValue);
    	}
    	
    	@AfterThrowing(pointcut="execution(public * addStudent(com.wajpzywj.vo.Student))",throwing="e")
    	public void myException(JoinPoint jp, NullPointerException e) { 
    		System.out.println("注解形式的一场通知----e:"+e.getMessage());
    	}
    	
    	@Around("execution(public * addStudent(com.wajpzywj.vo.Student))")
    	public void myAround(ProceedingJoinPoint jp) { 
    		System.out.println("注解环绕===前置通知");
    		try { 
    			//方法体2
    			jp.proceed(); //执行方法
    			System.out.println("注解环绕===后置通知");
    		} catch (Throwable e) { 
    			//方法体3
    			System.out.println("注解环绕===异常的的得到的的的通知");
    		} finally { 
    			System.out.println("注解环绕===最终通知");
    		}
    	}
    	@After("execution(public * addStudent(com.wajpzywj.vo.Student))")
    	public void myAfter() { 
    		System.out.println("注解环绕===最终==========通知");
    	}
    }

> 1.扫描器 会将指定的包中的 @Component@Repository@Service@Controller修饰的类产生的对象  
> 2.@Aspect 不需要加入扫描器， 只需要开启即可：`<aop:aspectj-autoproxy></aop:aspectj-autoproxy>`  
> 3. 通过注解形式 实现的aop，如果想获取 目标对象的一些参数，则需要使用一个对象JoinPoint  
> 4.注解形式的返回值：  
> a. 声明返回值 的参数名：

@AfterReturning(pointcut="execution(public * addStudent(com.wajpzywj.vo.Student))",returning = "returningValue")
    public void myAfterReturn(JoinPoint jp,Object returningValue) { 
    	System.out.println("注解-----后置方法:目标对象："+jp.getTarget()
    	+",方法："+jp.getSignature().getName()+",参数列表："+Arrays.toString(jp.getArgs())+"，返回值："+returningValue);
    }

> 注解形式实现aop时，通知的方法的参数不能多，不能少

**三、spring中事务**  
spring管理事务的属性介绍  
(1)事务的隔离级别  
(2)是否只读  
(3)事务的传播行为

> 目标：通过事务 使以下方法 要么全成功，要么全失败

**第一种：普通配置的事务**

1.  导入jar包

> spring-tx-4.3.9.RELEASE  
> ojdbc.jar 连接数据库  
> commons-dbcp.jar 连接池使用到数据源  
> commons-pool.jar 连接池  
> spring-jdbc-4.3.9.RELEASE.jar  
> aopalliance.jar

1.  xml配置

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    	<tx:attributes>
    		<tx:method name="addStudent" isolation="REPEATABLE_READ" read-only="false" propagation="REQUIRED"/>
    		<tx:method name="deleteStudent" isolation="REPEATABLE_READ" read-only="false" propagation="REQUIRED"/>
    	</tx:attributes>
    </tx:advice>
    
    <aop:config>
    	<aop:pointcut expression="execution(public void com.wajpzywj.service.impl.StudentServiceImpl.addStudent(com.wajpzywj.vo.Student))" id="txPc"/>
    	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPc"/>
    </aop:config>
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    	<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    	<property name="url" value="jdbc:mysql://localhost:3306/test"></property>
    	<property name="username" value="root"></property>
    	<property name="password" value="root"></property>
    </bean>

**第二种：注解形式的事务**

1.  导入jar包

> spring-tx-4.3.9.RELEASE  
> ojdbc.jar 连接数据库  
> commons-dbcp.jar 连接池使用到数据源  
> commons-pool.jar 连接池  
> spring-jdbc-4.3.9.RELEASE.jar  
> aopalliance.jar

1.  xml配置

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    	<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    	<property name="url" value="jdbc:mysql://localhost:3306/test"></property>
    	<property name="username" value="root"></property>
    	<property name="password" value="root"></property>
    </bean>
    
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource"></property>
    </bean>
    
    
    <tx:annotation-driven transaction-manager="transactionManager"/>

1.  在方法上面写注解

> @Transactional(isolation=Isolation.REPEATABLE\_READ,readOnly=false,propagation=Propagation.REQUIRED)

@Transactional(readOnly=false,propagation=Propagation.REQUIRED)
    @Override
    public void addStudent(Student student) { 
    	studentDao = null; //测试异常通知
    	studentDao.addStudent(student);
    }

**四、spring整合jdbc**

> spring中提供了一个可以操作数据库的对象，对象封装了jdbc技术 ————JDBCTemplate  
> JDBC模板对象，而JdbcDaoSupport则对JdbcTemplate进行了封装，所以要操作JdbcTemplate，或只需要继承JdbcDaoSupport即可。

参考：[https://blog.csdn.net/itcats\_cn/article/details/81479185][https_blog.csdn.net_itcats_cn_article_details_81479185]

**五、spring开发web项目**

> 问：web项目如何初始化springIOC容器：  
> 答：web项目启动时，会自动加载web.xml，因此需要在web.xml中加载监听器（ioc容器初始化）

1.  需要的jar包：  
    ![在这里插入图片描述][20190413084942468.png]

> 注意：web项目的jar包 是存放在WEB-INF/lib中

1.  在web中添加监听器监听aplicatioanContext.xml

> 两种方式：
> 
> 1.  必须告诉监听器此容器的位置：context-param
> 2.  默认约定的位置：WEB-INF/applicationcontext.xml

第一种：applicationContext.xml放在src目录下面，名字可以变，对应就可以了。

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
      <display-name>springweb</display-name>
      <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
      </welcome-file-list>
      
    	
    	<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:applicationContext1.xml</param-value>
    	</context-param>
      
      	
    	<listener>
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    </web-app>

第二种：applicationContext.xml放在WEB-INF目录下面，名字不能变，可以不配置`<context-param></context-param>`。

**六、拆分spring配置文件**

**1. java项目：**  
applicationContext1.xml;  
applicationContext2.xml;  
applicationContext3.xml;

> 注意：不存在拆分，需要用到那个xml，实例化哪个xml就可以了。

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

**2. web项目：**

> 三种方式：
> 
> 1.  分别`<param-name>`中写出名字
> 2.  在`<param-name>`中用通配符
> 3.  在applicationContext.xml中使用引入的方式

第一种：web中配置

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
      <display-name>springweb</display-name>
      <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
      </welcome-file-list>
      
    	
    	<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:applicationContext.xml</param-value>
    		<param-value>classpath:applicationContext-Dao.xml</param-value>
    		<param-value>classpath:applicationContext-Service.xml</param-value>
    		<param-value>classpath:applicationContext-Controller.xml</param-value>
    	</context-param>
      
      	
    	<listener>
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    </web-app>

第二种：web中配置

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
      <display-name>springweb</display-name>
      <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
      </welcome-file-list>
      
    	
    	<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:applicationContext.xml</param-value>
    		<param-value>classpath:applicationContext-*.xml</param-value>
    	</context-param>
      
      	
    	<listener>
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    </web-app>

第三种：先web中配置主配置文件applicationContext.xml，然后在applicationContext.xml中引入其他的xml文件。

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

[https_blog.csdn.net_itcats_cn_article_details_81479185]: /images/20220220/02b3ccf14ae54a38af1a3020fa079b02.png
[https_www.cnblogs.com_goodcheap_p_6490896.html]: https://www.cnblogs.com/goodcheap/p/6490896.html
[20190412092401574.png]: https://img-blog.csdnimg.cn/20190412092401574.png
[20190412091744943.png]: /images/20220220/4a1ee0e4882d4ab0bc5194dbb6c6346a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70]: /images/20220220/58c52a43d95944c7a4bdd75f99cda674.png
[20190413084942468.png]: /images/20220220/4d109b730e084e9da8bf2edc4b022f8f.png