Spring-IOC

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>
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值