springboot持久层在哪

转载

attitude 2025-10-23 11:03:38

文章标签 springboot持久层在哪 java 测试数据库 System 文章分类 架构后端开发

1、spring是什么？

sprint其实就是一个开源框架，是于2003年兴起的一个轻量级的java开发框架，是有Road Johnson创建的，简单的来说spring是一个分层的JavaSE/EE（full-stack）也就是一站式轻量级的开源框架

J2EE三层架构体系：

表现层（页面数据显示，页面跳转调度）jsp/servlet

业务层（业务处理和功能逻辑，事务控制） service

持久层（数据存取和封装和数据库打交道）dao

spring框架主要有：Spring MVC 和JDBCTemplate模块。

一般就是再使用的时候：在表现层使用Struts2和Spring MVC 在业务层使用的是Spring 在持久层使用的是hibernate和JDBCTemplate

2、Spring的核心技术

IOC（表示的是反转控制）也就是说将对象的创建权利交给Spring工场进行管理

AOP（表示的是面向切面编程）原理是基于动态代理功能增强

3、学习Spring技术的好处

(1)、方便解耦简化代码的开发-------Spring就是一个大工厂，可以将所有的对象的创建和关系的维护，交给Spring管理

(2)、AOP编程的支持-------Spring提供了面向切面编程，可以方便的实现对程序进行权限拦截，运行监控和声明事务等功能

(3)、声明事务的支持-------只需要进行配置就可以完成对事务的管理，而无需动手进行编程

(4)、方便程序的测试--------Spring对Junit4支持，可以通过注解方便测试你Spring程序，方便继承各种优秀的框架

　　总结：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的支持（如Struts、Hibernate、MyBatis、Quartz）

总结介绍使用：

IOC（Inverse of Control）也就是控制反转就对象的创建权利交给Spring容器

解决问题：使用IOC可以解决程序耦合性过高的问题

IOC原理接受和准备工作

1、创建UserDao借口以及实现类UserDaoImpl

package cn.itcast.dao;
 
public interface UserDao {
 
   public void save();
  
}
实现类
package cn.itcast.dao.impl;
 
import cn.itcast.dao.UserDao;
 
public class UserDaoImpl implements UserDao {
 
   @Override
   public void save() {
      System.out.println("持久层：用户保存");
   }
 
}
 
2、创建UserService借口和实现类UserServiceImpl
    
package cn.itcast.service;
 
public interface UserService {
 
   public void save();
  
}
实现类
package cn.itcast.service.impl;
 
import cn.itcast.dao.UserDao;
import cn.itcast.dao.impl.UserDaoImpl;
import cn.itcast.service.UserService;
 
public class UserServiceImpl implements UserService {
  
   private UserDao userDao = new UserDaoImpl();
  
   @Override
   public void save() {
      System.out.println("业务层：用户保存");
      userDao.save();
   }
 
}
 
3、创建测试类测试
package cn.itcast.test;
 
import org.junit.Test;
 
import cn.itcast.service.UserService;
import cn.itcast.service.impl.UserServiceImpl;
 
public class Test1 {
 
   @Test
   public void test(){
      UserService userService = new UserServiceImpl();
      userService.save();
   }
}
 
4、创建另一个UserDao借口的实现类UserDaoImpl2
 
package cn.itcast.dao.impl;
 
import cn.itcast.dao.UserDao;
 
public class UserDaoImpl2 implements UserDao{
 
   @Override
   public void save() {
      System.out.println("持久层：用户保存2");
   }
 
}
 观察以上程序发现：UserService和UserDao耦合性过高，如果需要更换一个 UserDao的实现，则是需要修改源代码的
 
那么就是需要创建工厂类解决耦合性问题方法
工厂类的创建
package cn.itcast.utils;
 
import cn.itcast.dao.UserDao;
import cn.itcast.dao.impl.UserDaoImpl;
 
public class BeanFactory {
 
   public static UserDao getBean(){
      return new UserDaoImpl();
   }
}

创建工厂类的时候接下来就是要修改上述代码（修改UserServiceImpl实现类来获取UserDao的方式）

修改代码如下：

public class UserServiceImpl implements UserService {
  
// private UserDao userDao = new UserDaoImpl();
  
// 采用工厂类获取UserDao对象
   private UserDao userDao = BeanFactory.getBean();
  
   @Override
   public void save() {
      System.out.println("业务层：用户保存");
      userDao.save();
   }
 
}
总结发现：这个时候观察总结发现：当需要更换UserDao的实现的时候，不需要修改UserServiceImpl类，不过此时需要进行修改工厂类
 
最终终极解决方法：可以创建配置文件彻底解决耦合性的问题
1、在src下创建配置文件beans.xml
      
<?xml version="1.0" encoding="UTF-8"?>
<bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl2"></bean>
2、同时修改工厂类从配置文件中读取对象
     代码如下：
public class BeanFactory {
  
   //存放所有的对象
   private static final Map<String,Object> map = new HashMap<String,Object>();
  
   static{
      SAXReader sax = new SAXReader();
      try {
         Document document = sax.read(BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml"));
         Element root = document.getRootElement();
         //获取id属性的值
         String id = root.attributeValue("id");
         //获取class属性的值
         String value = root.attributeValue("class");
         //根据class属性的值实例化对象
         Object obj = Class.forName(value).newInstance();
         //把对象存放到Map中
         map.put(id, obj);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
  
   /**
    * 根据id获取对象
    * @param id
    * @return
    */
   public static Object getBean(String id){
      return map.get(id);
   }
}
 
3、修改UserServiceImpl类
public class UserServiceImpl implements UserService {
  
// private UserDao userDao = new UserDaoImpl();
  
// 采用工厂类获取UserDao对象
// private UserDao userDao = BeanFactory.getBean();
  
// 从配置文件中读取需要的对象
   private UserDao userDao = (UserDao) BeanFactory.getBean("userDao");
 
   @Override
   public void save() {
      System.out.println("业务层：用户保存");
      userDao.save();
   }
 
}
这个时候总结发现：当需要更改UserDao的时候，只需要修改配置文件就可以实现，不用更改源代码了，这个时候程序也就是会彻底解决耦合性过高的问题
 
3、Spring开发包的下载：
 1.)官网地址：https://spring.io/
 2）下载 地址：http://repo.spring.io/libs-release-local/org/springframework/spring/    建议下载4.2.4这个版本
介绍一个开发包的目录结构：
docs    表示的是开发文档
libs      表示开发时候所需要的jar包
schema：表示开发的时候所需要的约束文件
其他 的暂时不用考虑
注意：开发过程中还需要其他开源技术框架依赖Jar包集（dependencies，作用是方便依赖的其他技术的jar的导入）
 
Spring核心容器中是需要四个jar包的：分别是beans 、context、Core、SpEl核心jar包
同时还需要加入和日志相关的两个jar包，从spring-framework-3.0.2.RELEASE-dependencies中寻找
 
 
 
5、介绍Spring中的工厂
5.1、

 使用ApplicationContext工厂的接口，使用该接口可以获取到具体的Bean对象
 该接口下有两个具体的实现类
 
 ClassPathXmlApplicationContext            -- 加载类路径下的Spring配置文件
 FileSystemXmlApplicationContext            -- 加载本地磁盘下的Spring配置文件
相关代码实现：
public class Test1 {
 
   @Test
   public void test1(){
applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
      UserDao userDao = (UserDao) applicationContext.getBean("userDao");
      userDao.save();
   }
  
   @Test
   public void test2(){
applicationContext = new FileSystemXmlApplicationContext("C:/spring/applicationContext.xml");
      UserDao userDao = (UserDao) applicationContext.getBean("userDao");
      userDao.save();
   }
  
}

1.1. BeanFactory工厂

早期版本的工厂介绍：

BeanFactory是Spring框架早期的创建Bean对象的工厂接口

/**

* 早期版本的spring工厂：BeanFactory

@Test

public void test3(){

BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

System.out.println("工厂对象创建出来了");

UserDao userDao = (UserDao) factory.getBean("userDao");

userDao.save();

}

BeanFactory和ApplicationContext的区别
            * BeanFactory   （表示的是早期的ioc工厂） -- BeanFactory采取延迟加载，第一次getBean时才会初始化Bean
            * ApplicationContext        -- 在加载applicationContext.xml时候就会创建具体的Bean对象的实例，还提供了一些其他的功能:
                 * 事件传递
                 * Bean自动装配
                 * 各种不同应用层的Context实现

6、Spring配置文件的介绍

6.1 id属性：id属性是bean的唯一标识

6.2 class属性：表示的是bean的全路径名称 <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl"/>

6.3 Scope属性：scope属性代表Bean的作用范围

singleton:单例（默认值）

prototype:多例，在Spring框架整合Struts2框架的时候，Action类也需要交给Spring做管理，配置把Action类配置成多例！！

request:应用在web应用中，将创建的对象存入到request域中。

session:应用在web应用中，将创建的对象存入到session域中

globalsession:应用在porlet环境下使用。将创建的对象存入到全局的session中。

实例：

singleton:单例（默认值） prototype:多例，在Spring框架整合Struts2框架的时候，Action类也需要交给Spring做管理，配置把Action类配置成多例！！ request:应用在web应用中，将创建的对象存入到request域中。 session:应用在web应用中，将创建的对象存入到session域中 globalsession:应用在porlet环境下使用。将创建的对象存入到全局的session中。

两者直接的区分：

修改测试类： ClassPathXMLApplication表示的你是直接从类路径下面进行加载，表示类只要一创建就立刻加载出来了。

@Test

public void test1(){

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

System.out.println("工厂对象创建出来了");

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

userDao1

userDao.save();

}

测试发现：当scope为prototype时，每次获取bean，都会重新实例化

6.4、init-method属性

当bean被载入到容器的时候调用init-method属性指定的方法

public class UserDaoImpl implements UserDao {

public UserDaoImpl() {

System.out.println("调用了UserDaoImpl的构造方法");

}

public void init(){

System.out.println("调用了init方法...");

}

@Override

public void save() {

System.out.println("用户保存...");

}

实例：

6.5、 destory-method属性

当bean从容器中删除的时候调用destroy-method属性指定的方法

想查看destroy-method的效果，有如下条件：

scope= singleton有效

web容器中会自动调用，但是main函数或测试用例需要手动调用（需要使用ClassPathXmlApplicationContext的close()方法）

@Test

public void test1(){

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

System.out.println("工厂对象创建出来了");

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

userDao.save();

//要看到destroy方法执行，需要调用ClassPathXmlApplicationContext.close方法

((ClassPathXmlApplicationContext)applicationContext).close();

}

总结：就是Spring框架的5中属性，分别是id属性，class属性，scope属性，init-method属性，destory-method属性

7、Spring生成bean的三种方式

7.1 表示无参构造方法--------------默认调用无参构造方法实例化bean

7.2 静态工厂实例化方式----------通过调用工厂类的静态方法实例化生成bean

n  编写DepartmentDao接口
package cn.itcast.dao;
 
public interface DepartmentDao {
 
   public void save();
}
n  编写DepartmentDaoImpl实现类
package cn.itcast.dao.impl;
 
import cn.itcast.dao.DepartmentDao;
 
public class DepartmentDaoImpl implements DepartmentDao{
 
   @Override
   public void save() {
      System.out.println("部门保存...");
   }
 
}
n  编写工厂类
package cn.itcast.dao.impl;
 
import cn.itcast.dao.DepartmentDao;
 
public class DepartmentDaoFactory {
 
   /**
    * 静态工厂方法获取对象
    * @return
    */
   public static DepartmentDao create(){
      return new DepartmentDaoImpl();
   }
}
n  编写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">
        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>
        <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean>
</beans>
 
7.3  实例工厂方式
      
n  实例工厂代码:
package cn.itcast.dao.impl;
 
import cn.itcast.dao.DepartmentDao;
 
public class DepartmentDaoFactory {
 
   /**
    * 静态工厂方法获取对象
    * @return
    */
   public static DepartmentDao create(){
      return new DepartmentDaoImpl();
   }
  
   /**
    * 实例工厂方法获取对象
    * @return
    */
   public DepartmentDao create1(){
      return new DepartmentDaoImpl();
   }
}
n  编写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">
        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>
       <!--  <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->
        <bean id="departmentDaoFactory" class="cn.itcast.dao.impl.DepartmentDaoFactory" ></bean>
        <bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>
</beans>

总结：Spring生成bean的三种方式：无参构造方法，静态工厂实例化方式，实力工厂方式

8、依赖注入（重点学习使用）（其中有八种方法可以实现依赖注入实现）

依赖注入的介绍：

IOC和DI的概念：
* IOC -- Inverse of Control，控制反转，将对象的创建权反转给Spring！！
* DI -- Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！

如果UserServiceImpl的实现类中有一个属性，那么使用Spring框架的IOC功能时，可以通过依赖注入把该属性的值传入进来！！

总共有八种：

1、构造方法注入

package cn.itcast.domain;
 
public class Car implements Serializable{
private static final long serialVersionUID = 1L;
   private String name;
   private Double price;
  
   public Car(String name, Double price) {
      this.name = name;
      this.price = price;
   }
 
   public String getName() {
      return name;
   }
 
   public void setName(String name) {
      this.name = name;
   }
 
   public Double getPrice() {
      return price;
   }
 
   public void setPrice(Double price) {
      this.price = price;
   }
 
   @Override
   public String toString() {
      return "Car [name=" + name + ", price=" + price + "]";
   }
  
}
n  配置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">
        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>
       <!--  <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->
        <bean id="departmentDaoFactory" class="cn.itcast.dao.impl.DepartmentDaoFactory" ></bean>
        <bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>
        <!-- 构造方法注入 -->
        <bean id="car" class="cn.itcast.domain.Car">
          <constructor-arg name="name" value="奥迪A6"></constructor-arg>
          <constructor-arg name="price" value="57.3"></constructor-arg>
        </bean>
</beans>
2、set方法注入
 
public class Student implements Serializable {
 
   private static final long serialVersionUID = 1L;
  
   private Long id;
   private String name;
  
   public Long getId() {
      return id;
   }
   public void setId(Long id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   @Override
   public String toString() {
      return "Student [id=" + id + ", name=" + name + "]";
   }
}
n  配置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">
        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>
       <!--  <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->
        <bean id="departmentDaoFactory" class="cn.itcast.dao.impl.DepartmentDaoFactory" ></bean>
        <bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>
        <!-- 构造方法注入 -->
        <bean id="car" class="cn.itcast.domain.Car">
          <constructor-arg name="name" value="奥迪A6"></constructor-arg>
          <constructor-arg name="price" value="57.3"></constructor-arg>
        </bean>
  <!-- set方法注入 -->
        <bean id="student" class="cn.itcast.domain.Student">
          <property name="id" value="11"></property>
          <property name="name" value="张三"></property>
        </bean>
</beans>
 
3、set方法注入的其他写法（不常用）
3.1  p命名空间的写法
新建car1类
package cn.itcast.domain;
 
public class Car1 {
 
   private String name;
   private double price;
  
   public void setName(String name) {
      this.name = name;
   }
在applicationContext.xml中引入p命名空间
 
 
   public void setPrice(double price) {
      this.price = price;
   }
   @Override
   public String toString() {
      return "Car1 [name=" + name + ", price=" + price + "]";
   }
  
}

springboot持久层在哪_测试

n 采用p:属性名的形式注入值（spring2.5提供的）

</bean>

SpEL的写法（spring3.0提供）

<!-- SpEL注入 -->
 <bean id="car1" class="cn.itcast.domain.Car1">
       <property name="name" value="#{'哈弗H5'}"></property>
        <property name="price" value="#{10}"></property>
 </bean>
注入字符串：#{‘字符串’}
注入数字：#{数字}
注入其它对象：#{对象id}
 <bean id="people" class="cn.itcast.domain.People">
          <property name="name" value="#{'小明'}"></property>
          <property name="car" value="#{car}"></property>
 </bean>
n  还可以注入其它对象的属性或方法的返回值
public class CarInfo {
 
   public String getCarName(){
      return "宝骏560";
   }
  
   public double calculatePrice(){
      return Math.random() * 10000;
   }
}
 
 <bean id="carInfo" class="cn.itcast.domain.CarInfo"></bean>
 <!-- SpEL注入 -->
<bean id="car1" class="cn.itcast.domain.Car1">
       <!-- <property name="name" value="#{'哈弗H5'}"></property>
       <property name="price" value="#{10}"></property> -->
       <property name="name" value="#{carInfo.carName}"></property>
       <property name="price" value="#{carInfo.calculatePrice()}"></property>
 </bean>
注意：#{carInfo.carName}会调用getCarName方法获取汽车的名称；而#{carInfo.calculatePrice()}会直接调用calculatePrice方法获取汽车价格。
 
5、数组或者是list注入
数组和list注入的写法是一样的
n  新建bean类
public class CollectionBean {
 
   private String[] array;
 
   public void setArray(String[] array) {
      this.array = array;
   }
 
   @Override
   public String toString() {
      return "CollectionBean [array=" + Arrays.toString(array) + "]";
   }
  
}
n  在applicationContext.xml中配置
<bean id="collectionBean" class="cn.itcast.domain.CollectionBean">
          <property name="array">
             <list>
                <value>威少</value>
                <value>哈登</value>
                <value>莱昂纳德</value>
             </list>
          </property>
</bean>
 
6.Set集合注入
public class CollectionBean {
 
   private String[] array;
   private Set<String> set;
 
   public void setArray(String[] array) {
      this.array = array;
   }
 
   public void setSet(Set<String> set) {
      this.set = set;
   }
 
   @Override
   public String toString() {
      System.out.println(set.getClass());
      return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + "]";
   }
 
}
 
<bean id="collectionBean" class="cn.itcast.domain.CollectionBean">
          <property name="array">
             <list>
                <value>威少</value>
                <value>哈登</value>
                <value>莱昂纳德</value>
             </list>
          </property>
          <property name="set">
             <set>
                <value>苹果</value>
                <value>梨子</value>
                <value>香蕉</value>
             </set>
          </property>
</bean>
提示：spring在注入set的时，给我们注入的是一个LinkedHashSet，所以在输入set集合中的元素时，是按照我们注入的顺序来的，并不是无序的。
 
 
7Map集合的注入
public class CollectionBean {
 
   private String[] array;
   private Set<String> set;
   private Map<String,String> map;
 
   public void setArray(String[] array) {
      this.array = array;
   }
 
   public void setSet(Set<String> set) {
      this.set = set;
   }
  
   public void setMap(Map<String, String> map) {
      this.map = map;
   }
 
   @Override
   public String toString() {
      return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + "]";
   }
 
}
 
<bean id="collectionBean" class="cn.itcast.domain.CollectionBean">
          <property name="array">
             <list>
                <value>威少</value>
                <value>哈登</value>
                <value>莱昂纳德</value>
             </list>
          </property>
          <property name="set">
             <set>
                <value>苹果</value>
                <value>梨子</value>
                <value>香蕉</value>
             </set>
          </property>
          <property name="map">
             <map>
                <entry key="id" value="11"></entry>
                <entry key="name" value="张三"></entry>
                <entry key="age" value="20"></entry>
             </map>
          </property>
</bean>
 
8、properties集合的注入
public class CollectionBean {
 
   private String[] array;
   private Set<String> set;
   private Map<String,String> map;
   private Properties props;
 
   public void setArray(String[] array) {
      this.array = array;
   }
 
   public void setSet(Set<String> set) {
      this.set = set;
   }
  
   public void setMap(Map<String, String> map) {
      this.map = map;
   }
 
   public void setProps(Properties props) {
      this.props = props;
   }
 
   @Override
   public String toString() {
      return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + ", props=" + props
            + "]";
   }
 
}
 
 <bean id="collectionBean" class="cn.itcast.domain.CollectionBean">
          <property name="array">
             <list>
                <value>威少</value>
                <value>哈登</value>
                <value>莱昂纳德</value>
             </list>
          </property>
          <property name="set">
             <set>
                <value>苹果</value>
                <value>梨子</value>
                <value>香蕉</value>
             </set>
          </property>
          <property name="map">
             <map>
                <entry key="id" value="11"></entry>
                <entry key="name" value="张三"></entry>
                <entry key="age" value="20"></entry>
             </map>
  </property>
          <property name="props">
             <props>
                <prop key="username">李四</prop>
                <prop key="password">123</prop>
             </props>
          </property>
 </bean>
 
1.1. 配置文件的分离
Spring配置文件的分离有两种方式：
（1）采用import标签导入另一个配置文件
Bean1类
 
public class Bean1 {
   private String xxx;
   public String getXxx() {
      return xxx;
   }
   public void setXxx(String xxx) {
      this.xxx = xxx;
   }
   @Override
   public String toString() {
      return "Bean1 [xxx=" + xxx + "]";
   }
}
 
applicationContext2.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:p="http://www.springframework.org/schema/p"
    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="bean1" class="cn.itcast.demo.Bean1">
      <property name="xxx" value="hello"></property>
    </bean>
</beans>
 
在applicationContext.xml中引入applicationContext2.xml文件
<import resource="applicationContext2.xml"/>
 
（2）在实例化ApplicationContext的时候，指定多个配置文件
@Test
   public void test9(){
ac = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");
      Bean1 bean1 = (Bean1) ac.getBean("bean1");
      System.out.println(bean1);
   }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。