Spring 基础知识之一解析

你猜 阅读:207 2021-03-31 14:14:54 评论:0

第一:Spring概述

         Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架,以 IoC(Inverse Of Control: 反转控制)和 AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多 著名的第三方框架和类库,逐渐成为使用最多的 Java EE 企业应用开源框架。

第二:Spring 体系结构

2.1 Spring 核心框架

核心容器由spring-core,spring-beans,spring-context,spring-context-support和spring-expression(SpEL,Spring表达式语言,Spring Expression Language)等模块组成,它们的细节如下:

1、spring-core模块提供了框架的基本组成部分,包括 IoC 和依赖注入功能。

2、spring-beans 模块提供 BeanFactory,工厂模式的微妙实现,它移除了编码式单例的需要,并且可以把配置和依赖从实际编码逻辑中解耦。

3、context模块建立在由core和 beans 模块的基础上建立起来的,它以一种类似于JNDI注册的方式访问对象。Context模块继承自Bean模块,并且添加了国际化(比如,使用资源束)、事件传播、资源加载和透明地创建上下文(比如,通过Servelet容器)等功能。Context模块也支持Java EE的功能,比如EJB、JMX和远程调用等。ApplicationContext接口是Context模块的焦点。spring-context-support提供了对第三方库集成到Spring上下文的支持,比如缓存(EhCache, Guava, JCache)、邮件(JavaMail)、调度(CommonJ, Quartz)、模板引擎(FreeMarker, JasperReports, Velocity)等。

4、spring-expression模块提供了强大的表达式语言,用于在运行时查询和操作对象图。它是JSP2.1规范中定义的统一表达式语言的扩展,支持set和get属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从Spring IoC容器检索对象,还支持列表的投影、选择以及聚合等。

2.2 Spring 模块之间的依赖关系

2.4 Spring 数据连接/集成模块

数据访问/集成层包括 JDBC,ORM,OXM,JMS 和事务处理模块,它们的细节如下:(注:JDBC=Java Data Base Connectivity,ORM=Object Relational Mapping,OXM=Object XML Mapping,JMS=Java Message Service)

1、JDBC 模块提供了JDBC抽象层,它消除了冗长的JDBC编码和对数据库供应商特定错误代码的解析。

2、ORM 模块提供了对流行的对象关系映射API的集成,包括JPA、JDO和Hibernate等。通过此模块可以让这些ORM框架和spring的其它功能整合,比如前面提及的事务管理。

3、OXM 模块提供了对OXM实现的支持,比如JAXB、Castor、XML Beans、JiBX、XStream等。

4、JMS 模块包含生产(produce)和消费(consume)消息的功能。从Spring 4.1开始,集成了spring-messaging模块。。

5、事务模块为实现特殊接口类及所有的 POJO 支持编程式和声明式事务管理。(注:编程式事务需要自己写beginTransaction()、commit()、rollback()等事务管理方法,声明式事务是通过注解或配置由spring自动处理,编程式事务粒度更细)

2.5 Spring Web

Web 层由 Web,Web-MVC,Web-Socket 和 Web-Portlet 组成,它们的细节如下:

1、Web 模块提供面向web的基本功能和面向web的应用上下文,比如多部分(multipart)文件上传功能、使用Servlet监听器初始化IoC容器等。它还包括HTTP客户端以及Spring远程调用中与web相关的部分。。

2、Web-MVC 模块为web应用提供了模型视图控制(MVC)和REST Web服务的实现。Spring的MVC框架可以使领域模型代码和web表单完全地分离,且可以与Spring框架的其它所有功能进行集成。

3、Web-Socket 模块为 WebSocket-based 提供了支持,而且在 web 应用程序中提供了客户端和服务器端之间通信的两种方式。

4、Web-Portlet 模块提供了用于Portlet环境的MVC实现,并反映了spring-webmvc模块的功能。

2.6 Spring 其他

其他一些重要的模块,像 AOP,Aspects,Instrumentation,Web 和测试模块,它们的细节如下:

1、AOP 模块提供了面向方面的编程实现,允许你定义方法拦截器和切入点对代码进行干净地解耦,从而使实现功能的代码彻底的解耦出来。使用源码级的元数据,可以用类似于.Net属性的方式合并行为信息到代码中。

2、Aspects 模块提供了与 AspectJ 的集成,这是一个功能强大且成熟的面向切面编程(AOP)框架。

3、Instrumentation 模块在一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现。

4、Messaging 模块为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型,它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息。

5、测试模块支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试。

第三:Spring 开发环境搭建(Spring IOC开发环境搭建)

3.1 Spring 依赖jar 如下:

<!--spring 框架依赖核心jar 包 --> 
		<dependency> 
			<groupId>org.springframework</groupId> 
			<artifactId>spring-context</artifactId> 
			<version>5.0.2.RELEASE</version> 
		</dependency> 
		<dependency> 
			<groupId>org.springframework</groupId> 
			<artifactId>spring-core</artifactId> 
			<version>5.0.2.RELEASE</version> 
		</dependency> 
		<dependency> 
			<groupId>org.springframework</groupId> 
			<artifactId>spring-beans</artifactId> 
			<version>5.0.2.RELEASE</version> 
		</dependency> 
		<dependency> 
			<groupId>org.springframework</groupId> 
			<artifactId>spring-expression</artifactId> 
			<version>5.0.2.RELEASE</version> 
		</dependency> 
		<!--spring 框架 log4j 日志集成(推荐使用logback) --> 
		<dependency> 
			<groupId>log4j</groupId> 
			<artifactId>log4j</artifactId> 
			<version>1.2.16</version> 
		</dependency> 
		<dependency> 
			<groupId>commons-logging</groupId> 
			<artifactId>commons-logging</artifactId> 
			<version>1.2</version> 
		</dependency>

3.2 持久层和业务层代码编写:

package com.zzg.spring.dao; 
 
/** 
 * 账户持久层接口 
 * @author Administrator 
 * 
 */ 
public interface IAccountDao { 
	/** 
	 * 账户保存 
	 */ 
	void saveAccount(); 
} 
 
 
package com.zzg.spring.dao.impl; 
 
import com.zzg.spring.dao.IAccountDao; 
 
/** 
 * 账户持久层接口实现类 
 * @author Administrator 
 * 
 */ 
public class AccountDaoImpl implements IAccountDao { 
 
	@Override 
	public void saveAccount() { 
		// TODO Auto-generated method stub 
		System.out.println("账户保存"); 
	} 
 
} 
 
 
package com.zzg.spring.service; 
 
/** 
 * 账户业务层接口 
 * @author Administrator 
 * 
 */ 
public interface IAccountService { 
	/** 
	 * 账户保存 
	 */ 
	void saveAccount(); 
} 
 
 
package com.zzg.spring.service.impl; 
 
import com.zzg.spring.dao.IAccountDao; 
import com.zzg.spring.service.IAccountService; 
 
/** 
 * 账户业务层接口实现类 
 * @author Administrator 
 * 
 */ 
public class AccountServiceImpl implements IAccountService { 
	// 注入持久层dao 
	private IAccountDao dao; 
	 
	public IAccountDao getDao() { 
		return dao; 
	} 
 
	public void setDao(IAccountDao dao) { 
		this.dao = dao; 
	} 
 
	@Override 
	public void saveAccount() { 
		// TODO Auto-generated method stub 
		dao.saveAccount(); 
	} 
 
} 

3.3 配置文件和测试功能代码

<?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="dao" class="com.zzg.spring.dao.impl.AccountDaoImpl"/> 
	 
	<!--实例化:账户业务成接口实现类  --> 
	<bean id="service" class="com.zzg.spring.service.impl.AccountServiceImpl"> 
		<property name="dao" ref="dao"></property> 
	</bean> 
</beans> 
package com.zzg.spring; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
import com.zzg.spring.service.IAccountService; 
 
public class Client { 
 
	public static void main(String[] args) { 
		//1.使用 ApplicationContext 接口,就是在获取 spring 容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); 
		//2.根据 bean 的 id 获取对象 
		IAccountService aService = (IAccountService) ac.getBean("service"); 
		aService.saveAccount(); 
	} 
 
} 

第四:Spring IOC 中Bean标签

4.1 Bean 标签作用:

       用于配置对象让 spring 来创建的。
       默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

4.2 Bean 标签属性:

       id:给对象在容器中提供一个唯一标识。用于获取对象。
       class:指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
       scope:指定对象的作用范围。
                   * singleton :默认值,单例的.
                   * prototype :多例的.
                   * request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
                   * session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
                   * global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
       init-method:指定类中的初始化方法名称。
       destroy-method:指定类中销毁方法名称。

4.3 Bean的三种实例化方式

4.3.1 使用默认无参构造函数

<!--在默认情况下: 
	它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数,将会创建失败。--> 
	<bean id="dao" class="com.zzg.spring.dao.impl.AccountDaoImpl"/>

4.3.2 spring 管理静态工厂-使用静态工厂的方法创建对象

package com.zzg.spring.factory; 
 
import com.zzg.spring.service.IAccountService; 
import com.zzg.spring.service.impl.AccountServiceImpl; 
/** 
 * spring 静态工程方法 
 * @author Administrator 
 * 
 */ 
public class StaticFactory { 
	public static IAccountService createAccountService(){ 
		return new AccountServiceImpl(); 
		} 
} 
<?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 中没有默认无参构造函数,将会创建失败。 --> 
	<bean id="dao" class="com.zzg.spring.dao.impl.AccountDaoImpl" /> 
 
	<!--实例化:账户业务成接口实现类 --> 
	<!-- 
	<bean id="service" 
		class="com.zzg.spring.service.impl.AccountServiceImpl"> 
		<property name="dao" ref="dao"></property> 
	</bean>  --> 
 
	<!-- 此种方式是: 使用 StaticFactory 类中的静态方法 createAccountService 创建对象,并存入 spring  
		容器 id 属性:指定 bean 的 id,用于从容器中获取 class 属性:指定静态工厂的全限定类名 factory-method 属性:指定生产对象的静态方法 --> 
	<bean id="accountService" 
		class="com.zzg.spring.factory.StaticFactory" 
		factory-method="createAccountService"></bean> 
</beans> 
package com.zzg.spring; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
import com.zzg.spring.dao.IAccountDao; 
import com.zzg.spring.service.impl.AccountServiceImpl; 
 
public class Client { 
 
	public static void main(String[] args) { 
		//1.使用 ApplicationContext 接口,就是在获取 spring 容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); 
		//2.根据 bean 的 id 获取对象 
		IAccountDao dao = (IAccountDao) ac.getBean("dao"); 
		 
		AccountServiceImpl service = (AccountServiceImpl) ac.getBean("accountService"); 
		service.setDao(dao); 
		service.saveAccount(); 
	} 
 
} 

4.3.3 spring 管理实例工厂-使用实例工厂的方法创建对象

package com.zzg.spring.factory; 
 
import com.zzg.spring.service.IAccountService; 
import com.zzg.spring.service.impl.AccountServiceImpl; 
 
/** 
 * spring 实例工厂方法 
 *  
 * @author Administrator 
 * 
 */ 
public class InstanceFactory { 
	public IAccountService createAccountService() { 
		return new AccountServiceImpl(); 
	} 
} 
<?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 中没有默认无参构造函数,将会创建失败。 --> 
	<bean id="dao" class="com.zzg.spring.dao.impl.AccountDaoImpl" /> 
 
	<!--实例化:账户业务成接口实现类 --> 
	<!-- <bean id="service" class="com.zzg.spring.service.impl.AccountServiceImpl">  
		<property name="dao" ref="dao"></property> </bean> --> 
 
	<!-- 此种方式是: 使用 StaticFactory 类中的静态方法 createAccountService 创建对象,并存入 spring  
		容器 id 属性:指定 bean 的 id,用于从容器中获取 class 属性:指定静态工厂的全限定类名 factory-method 属性:指定生产对象的静态方法 --> 
	<!-- 
	<bean id="accountService" 
		class="com.zzg.spring.factory.StaticFactory" 
		factory-method="createAccountService"></bean>  --> 
 
	<!-- 此种方式是: 先把工厂的创建交给 spring 来管理。 然后在使用工厂的 bean 来调用里面的方法 factory-bean 属性:用于指定实例工厂  
		bean 的 id。 factory-method 属性:用于指定实例工厂中创建对象的方法。 --> 
	<bean id="instancFactory" 
		class="com.zzg.spring.factory.InstanceFactory"></bean> 
	<bean id="accountService" factory-bean="instancFactory" 
		factory-method="createAccountService"></bean> 
</beans> 
package com.zzg.spring; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
import com.zzg.spring.dao.IAccountDao; 
import com.zzg.spring.service.impl.AccountServiceImpl; 
 
public class Client { 
 
	public static void main(String[] args) { 
		//1.使用 ApplicationContext 接口,就是在获取 spring 容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); 
		//2.根据 bean 的 id 获取对象 
		IAccountDao dao = (IAccountDao) ac.getBean("dao"); 
		 
		AccountServiceImpl service = (AccountServiceImpl) ac.getBean("accountService"); 
		service.setDao(dao); 
		service.saveAccount(); 
	} 
 
} 

第五:Spring 依赖注入

5.1 Spring 依赖注入核心概念

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

5.2 Spring 依赖注入的几种方式

5.2.1 构造函数注入

         使用构造函数的方式,给 bean中的属性传值 要求: 类中需要提供一个对应参数列表的构造函数。
         构造函数涉及的标签(constructor-arg):
                index:指定参数在构造函数参数列表的索引位置
                type:指定参数在构造函数中的数据类型
                name:指定参数在构造函数中的名称
                value:它能赋的值是基本数据类型和 String 类型
                ref:它能赋的值是其他 bean 类型,也就是说,必须得是在配置文件中配置过的 bean
 
         示例代码:
package com.zzg.spring.entity; 
 
import java.util.Date; 
 
/** 
 * 用户实体对象 
 * @author Administrator 
 * 
 */ 
public class UserEntity { 
	private String name; 
	private Integer age; 
	private Date birthday; 
	 
	public String getName() { 
		return name; 
	} 
	public void setName(String name) { 
		this.name = name; 
	} 
	public Integer getAge() { 
		return age; 
	} 
	public void setAge(Integer age) { 
		this.age = age; 
	} 
	public Date getBirthday() { 
		return birthday; 
	} 
	public void setBirthday(Date birthday) { 
		this.birthday = birthday; 
	} 
	//构造函数 
	public UserEntity(String name, Integer age, Date birthday) { 
		super(); 
		this.name = name; 
		this.age = age; 
		this.birthday = birthday; 
	} 
 
	@Override 
	public String toString() { 
		// TODO Auto-generated method stub 
		System.out.println(name+","+age+","+birthday); 
		return super.toString(); 
	} 
} 
<?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="dateFormat" class="java.text.SimpleDateFormat"> 
		<constructor-arg value="yyyy-MM-dd" /> 
	</bean> 
	<bean id="userEntity" class="com.zzg.spring.entity.UserEntity"> 
		<constructor-arg name="name" value="张三"></constructor-arg> 
		<constructor-arg name="age" value="18"></constructor-arg> 
		<constructor-arg name="birthday"> 
			  <bean factory-bean="dateFormat" factory-method="parse">   
                <constructor-arg value="2020-05-11" />   
            </bean>   
		</constructor-arg> 
	</bean> 
</beans> 
package com.zzg.spring; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
import com.zzg.spring.entity.UserEntity; 
 
public class Constructor { 
 
	public static void main(String[] args) { 
		// TODO Auto-generated method stub 
		//1.使用 ApplicationContext 接口,就是在获取 spring 容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("constructor.xml"); 
		//2.根据 bean 的 id 获取对象 
		UserEntity entity = (UserEntity) ac.getBean("userEntity"); 
		entity.toString(); 
	} 
 
} 

 

5.2.2 set方法注入
 
        set方法涉及标签(property):
                   name:找的是类中 set 方法后面的部分
                   ref:给属性赋值是其他 bean 类型的
                   value:给属性赋值是基本数据类型和 string 类型的
 
         示例代码:
package com.zzg.spring.entity; 
 
import java.util.Date; 
 
/** 
 * 用户实体对象 
 * @author Administrator 
 * 
 */ 
public class UserEntity { 
	private String name; 
	private Integer age; 
	private Date birthday; 
	 
	public String getName() { 
		return name; 
	} 
	public void setName(String name) { 
		this.name = name; 
	} 
	public Integer getAge() { 
		return age; 
	} 
	public void setAge(Integer age) { 
		this.age = age; 
	} 
	public Date getBirthday() { 
		return birthday; 
	} 
	public void setBirthday(Date birthday) { 
		this.birthday = birthday; 
	} 
	 
 
	@Override 
	public String toString() { 
		// TODO Auto-generated method stub 
		System.out.println(name+","+age+","+birthday); 
		return super.toString(); 
	} 
	 
} 
<?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="dateFormat" class="java.text.SimpleDateFormat"> 
		<constructor-arg value="yyyy-MM-dd" /> 
	</bean> 
	<bean id="userEntity" class="com.zzg.spring.entity.UserEntity"> 
		<property name="name" value="张三"></property> 
		<property name="age" value="18"></property> 
		<property name="birthday"> 
			  <bean factory-bean="dateFormat" factory-method="parse">   
                <constructor-arg value="2020-05-11" />   
            </bean>   
		</property> 
	</bean> 
</beans> 
package com.zzg.spring; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
import com.zzg.spring.entity.UserEntity; 
 
public class Constructor { 
 
	public static void main(String[] args) { 
		// TODO Auto-generated method stub 
		//1.使用 ApplicationContext 接口,就是在获取 spring 容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("constructor.xml"); 
		//2.根据 bean 的 id 获取对象 
		UserEntity entity = (UserEntity) ac.getBean("userEntity"); 
		entity.toString(); 
	} 
 
} 

 

 5.2.3 注入集合属性
          顾名思义,就是给类中的集合成员传值,它用的也是set方法注入的方式,只不过变量的数据类型都是集合。我们这里介绍注入数组,List,Set,Map,Properties。
 
示例:
package com.zzg.spring.entity; 
 
import java.util.List; 
import java.util.Map; 
import java.util.Properties; 
import java.util.Set; 
 
public class SchoolEntity { 
	private List<String> myList; 
	private Set<String> mySet; 
	private Map<String,String> myMap; 
	private Properties myProps; 
	 
	public List<String> getMyList() { 
		return myList; 
	} 
	public void setMyList(List<String> myList) { 
		this.myList = myList; 
	} 
	public Set<String> getMySet() { 
		return mySet; 
	} 
	public void setMySet(Set<String> mySet) { 
		this.mySet = mySet; 
	} 
	public Map<String, String> getMyMap() { 
		return myMap; 
	} 
	public void setMyMap(Map<String, String> myMap) { 
		this.myMap = myMap; 
	} 
	public Properties getMyProps() { 
		return myProps; 
	} 
	public void setMyProps(Properties myProps) { 
		this.myProps = myProps; 
	} 
} 
<?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="school" class="com.zzg.spring.entity.SchoolEntity"> 
		<!-- 注入 list 集合数据 --> 
		<property name="myList"> 
			<array> 
				<value>AAA</value> 
				<value>BBB</value> 
				<value>CCC</value> 
			</array> 
		</property> 
		<!-- 注入 set 集合数据 --> 
		<property name="mySet"> 
			<list> 
				<value>AAA</value> 
				<value>BBB</value> 
				<value>CCC</value> 
			</list> 
		</property> 
		<!-- 注入 Map 数据 --> 
		<property name="myMap"> 
			<props> 
				<prop key="testA">aaa</prop> 
				<prop key="testB">bbb</prop> 
			</props> 
		</property> 
		<!-- 注入 properties 数据 --> 
		<property name="myProps"> 
			<map> 
				<entry key="testA" value="aaa"></entry> 
				<entry key="testB"> 
					<value>bbb</value> 
				</entry> 
			</map> 
		</property> 
	</bean> 
 
</beans> 
package com.zzg.spring; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
import com.zzg.spring.entity.SchoolEntity; 
 
public class Aggregate { 
 
	public static void main(String[] args) { 
		//1.使用 ApplicationContext 接口,就是在获取 spring 容器 
		ApplicationContext ac = new ClassPathXmlApplicationContext("aggregate.xml"); 
		//2.根据 bean 的 id 获取对象 
		SchoolEntity entity = (SchoolEntity) ac.getBean("school"); 
		System.out.println(String.join(",", entity.getMyList())); 
		entity.toString(); 
	} 
 
} 

 

        

 

 

声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

发表评论
搜索
排行榜
KIKK导航

KIKK导航

关注我们