Spring-IOC

最新推荐文章于 2025-06-01 16:47:32 发布

原创最新推荐文章于 2025-06-01 16:47:32 发布 · 230 阅读

1 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

120 篇文章

订阅专栏

Spring框架是一种非侵入式设计的框架，主要用于解决对象创建和依赖关系处理。它支持控制反转（IOC）、依赖注入（DI），以及面向切面编程（AOP）。Spring提供了包括核心功能、Web模块、DAO支持、ORM整合、AOP编程和Java EE模块的一站式解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

spring框架

专业术语了解

组件/框架设计：
	侵入式设计
		引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。
			例如：	Struts框架
	非侵入式设计
		引入了框架，对现有的类结构没有影响。
			例如：Hibernate框架 / Spring框架
			
控制反转:
	Inversion on Control , 控制反转 IOC
	对象的创建交给外部容器完成，这个就做控制反转.

依赖注入  
	dependency injection 处理对象的依赖关系

	区别：
 		控制反转， 解决对象创建的问题 【对象创建交给别人】
	依赖注入，
		在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】
		
AOP
	面向切面编程。切面，简单来说来可以理解为一个类，由很多重复代码形成的类。
	切面举例：事务、日志、权限;

概述

Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。
			且可以和其他框架一起使用；Spring与Struts,  Spring与hibernate
			(起到整合（粘合）作用的一个框架)
			
Spring提供了一站式解决方案：
	1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系
	2） Spring Web  Spring对web模块的支持。
						- 可以与struts整合,让struts的action创建交给spring
					    - spring mvc模式
	3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】
	4） Spring ORM  spring对orm的支持： 
						 既可以与hibernate整合，【session】
						 也可以使用spring的对hibernate操作的封装
	5）Spring AOP  切面编程
	6）SpringEE   spring 对javaEE其他模块的支持

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    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">
	
</beans>

API

细节

/**
	 * 1) 对象创建： 单例/多例
	 * 	scope="singleton", 默认值， 即 默认是单例	【service/dao/工具类】
	 *  scope="prototype", 多例； 				【Action对象】
	 * 
	 * 2) 什么时候创建?
	 * 	  scope="prototype"  在用到对象的时候，才创建对象。
	 *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
	 * 3)是否延迟创建
	 * 	  lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象
	 * 	  lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象
	 *    （只对单例有效）
	 * 4) 创建对象之后，初始化/销毁
	 * 	  init-method="init_user"       【对应对象的init_user方法，在对象创建爱之后执行 】
	 *    destroy-method="destroy_user"  【在调用容器对象的destriy方法时候执行，(容器用实现类)】
	 */
	 
	@Test
	public void testIOC() throws Exception {
		// 得到IOC容器对象  【用实现类，因为要调用销毁的方法】
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 从容器中获取bean
		User user1 = (User) ac.getBean("user");
		User user2 = (User) ac.getBean("user");
		
		System.out.println(user1);
		System.out.println(user2);
		
		// 销毁容器对象 
		ac.destroy();
	}

配置文件：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"
    xmlns:p="http://www.springframework.org/schema/p"
    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">
	
	<!-- ###############对象创建############### -->
	
	<!-- 1. 默认无参数构造器 
	<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
	-->
	
	<!-- 2. 带参数构造器 -->
	<bean id="user2" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
	</bean>
	
	<!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
	<bean id="str" class="java.lang.String">
		<constructor-arg value="Jacks"></constructor-arg>
	</bean>
	<bean id="user3" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
	</bean>
	
	
	<!-- 3. 工厂类创建对象 -->
	<!-- # 3.1 工厂类，实例方法 -->
	<!-- 先创建工厂 -->
	<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
	<!-- 在创建user对象，用factory方的实例方法 -->
	<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
	
	
	<!-- # 3.2 工厂类： 静态方法 -->
	<!-- 
		class 指定的就是工厂类型
		factory-method  一定是工厂里面的“静态方法”
	 -->
	<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
	
</beans>

public class App {

	// 1. 通过工厂类得到IOC容器创建的对象
	@Test
	public void testIOC() throws Exception {
		// 创建对象
		// User user = new User();
		
		// 现在，把对象的创建交给spring的IOC容器
		Resource resource = new ClassPathResource("applicationContext.xml");
		
		// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
		BeanFactory factory = new XmlBeanFactory(resource);
		
		// 得到容器创建的对象
		User user = (User) factory.getBean("user");
		
		System.out.println(user.getId());

	}
	
	//2. （方便）直接得到IOC容器对象 
	@Test
	public void testAc() throws Exception {
		// 得到IOC容器对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 从容器中获取bean
		User user = (User) ac.getBean("user");
		
		System.out.println(user);
		
	}
}

实例

实例1：依赖注入

实体类：User.java

public class User {

	private String name;
	private int age;
	private String sex；

	......（省略Setter()与Getter()方法）

配置文件：applicationContext.xml

<!-- bean标签定义JavaBean的名称和类型  -->    

<bean id="user" class="spring.User">
	<property name="name">
		<value>小强</value>
	</property>
	<property name="age">
		<value>18</value>
	</property>
	<property name="sex">
		<value>男</value>
	</property>
</bean>

实现类：APP.java

public static void main(String[] args) throws Exception{
		
		/*
		 * 使用BeanFactory管理bean,通过从XML配置文件或属性文件（properties）中
		 * 读取javaBean的定义，来实现javaBean的创建，配置，管理
		 * 装载配置文件的3个实现类
		 * 1.当前路径		ApplicationContext ac = new ClassPathXmlApplicationContext(String Controller);
		 * 2.不止当前路径		ApplicationContext ac = new FileSystemXmlApplicationContext(String Controller);
		 * 3.在Servlet的web.xml文件中配置Spring的ContextLoaderListener监听器
		 * 或修改web.xml配置文件中添加一个Servlet，定义使用Spring的org.springframework.web.context.ContextLoaderServlet类
		*/
		
		//装载配置文件
		Resource resource = new ClassPathResource("spring/applicationContext.xml");
		BeanFactory factory = new XmlBeanFactory(resource);
		
		//获取bean
		User user = (User)factory.getBean("user");
		System.out.println("姓名：" + user.getName());
		System.out.println("年龄：" + user.getAge());
		System.out.println("性别：" + user.getSex());
		
	}

实例2：构造器注入

User.java

    	//构造器注入	它的构造方法被调用并且只能调用一次，所以构造器常被用于类的初始化操作
    	
	public User(String name,Integer age,String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	
	public void printInfo() {
		System.out.println("姓名：" + name);
		System.out.println("年龄：" + age);
		System.out.println("性别：" + sex);
	}

applicationContext.xml

<bean id="user" class="spring.User">
  	//可以为构造方法传参
   	<constructor-arg>
   		<value>小强</value>
   	</constructor-arg>
   	<constructor-arg>
   		<value>18</value>
   	</constructor-arg>
   	<constructor-arg>
   		<value>男</value>
   	</constructor-arg>
</bean>

APP.java

Resource resource = new ClassPathResource("spring/applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);
User user = (User)factory.getBean("user");
user.printInfo();

实例3：引入其他的bean

applicationContext.xml

<bean name="/main.do" class="spring.Manger">
     	<property name="user">
     		<ref local="user"/>
     	</property>
     </bean>

web.xml

<servlet>
	    <servlet-name>DispatcherServlet</servlet-name>
	    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	    通知DispatcherServlet去指定的目录下加载applicationContext.xml配置文件
	    <init-param>
	      <param-name>contextConfigLocation</param-name>
	      <param-value>classpath:/WEB-INF/applicationContext.xml</param-value>
	    </init-param>
	    <load-on-startup>1</load-on-startup>
	  </servlet>
	  <servlet-mapping>
	    <servlet-name>DispatcherServlet</servlet-name>
	    <url-pattern>*.do</url-pattern>
	  </servlet-mapping>
<servlet>

App.java

public class App extends AbstractControController{
	private User user;
	
	public User getUser(){
		return user;
	}
	
	public User setUser(){
		this.user = user;
	}
	protected ModelAndView handleRequestInternal(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {
		// TODO Auto-generated method stub
		user.printInfo();
		return null;
	}
}

实例4：自动装配

PrintInfo.java

package spring;


/*
 * 自动装配
 * 		<bean>元素的byname属性以属性名或类型区分自动装配。
 * 		在容器中寻找与javabean的属性名相同的Javabean,
 * 		并将其自动装配到javabean中
 * */

public class PrintInfo {

	private User user;
	
	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}
	
	public void PrintUser() {
		System.out.println("姓名：" + user.getName());
		System.out.println("年龄：" + user.getAge());
		System.out.println("性别：" + user.getSex());	
	}
}

APP.java

Resource resource = new ClassPathResource("spring/applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);

//获取bean
PrintInfo printInfo = (PrintInfo)factory.getBean("printInfo");
printInfo.PrintUser();

//名称装配
<bean autowire="byName" id="printInfo" class="spring.PrintInfo"></bean>

//类型装配
<bean autowire="byType" id="printInfo" class="spring.PrintInfo"></bean>