Spring框架入门（一）——IoC、DI、装配Bean

程序员文章站 2022-05-14 23:46:03

...

1.Spring简介

Spring是于2003 年兴起的一个分层轻量级开源Java 开发框架，它是为了解决企业应用开发的复杂性而创建的，创始人Rod Johnson。

轻量级：与EJB对比，依赖资源少，消耗的资源少。

分层：一站式 ，每一个层都提供解决方案

~表现层（Web层）：Spring MVC

~业务逻辑层（Service层）：Spring的IoC

~数据访问层（DAO层）：Spring的jdbcTemplate

Spring以IoC、AOP为主要思想，其中IoC，Inversion of Control 指控制反转或反向控制。在Spring框架中我们通过配置创建类对象，由Spring在运行阶段实例化、组装对象。AOP，Aspect Oriented Programming，面向切面编程，其思想是在执行某些代码前执行另外的代码，使程序更灵活、扩展性更好，可以随便地添加、删除某些功能。Servlet中的Filter便是一种AOP思想的实现。

优点之一：方便解耦，简化开发

~Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理

~Spring工厂是用于生成bean

Spring体系结构：Spring 框架是一个分层架构,,它包含一系列的功能要素并被分为大约20个模块。这些模块分为Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming)、Instrumentation和测试部分,如下图所示：

Spring框架入门（一）——IoC、DI、装配Bean

2.入门案例：IoC（掌握）

2.1导入jar包

4 + 1 ： 4个核心（beans、core、context、expression） + 1个依赖（commons-loggins...jar）

Spring框架入门（一）——IoC、DI、装配Bean

2.2目标类

~提供UserService接口和实现类

~获得UserService实现类的实例

注：之前开发中，直接new一个对象即可。

学习spring之后，将由Spring创建对象实例--> IoC 控制反转（Inverse of Control）

之后需要实例对象时，从spring工厂（容器）中获得，需要将实现类的全限定名称配置到xml文件中

public interface UserService {
	
	public void addUser();

}

public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		System.out.println("a_ico add user");
	}

}

2.3配置文件

~位置：任意，开发中一般在classpath下（src）

~名称：任意，开发中常用applicationContext.xml

~内容：添加schema约束

约束文件位置：spring-framework-3.2.0.RELEASE\docs\spring-framework-reference\html\ xsd-config.html

<?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">
	<!-- 配置service 
		<bean> 配置需要创建的对象
			id ：用于之后从spring容器获得实例时使用的
			class ：需要创建实例的限定类名
	-->
	<bean id="userServiceId" class="com.itheima.a_ioc.UserServiceImpl"></bean>
</beans>

2.4测试

public class TestIoC {
	
//	@Test
//	public void demo01()
//	{
//		//之前开发
//		UserService userService=new UserServiceImp();
//		userService.addUser();
//	}

        @Test
	public void demo02()
	{
		//从Spring容器获得
		//1.获得容器
		String xmlPath="com/itheima/ioc/beans.xml";
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
		//2.获得内容，不需要自己new，都是从Spring容器中获得
		UserService userService= (UserService)applicationContext.getBean("userServiceId");
		userService.addUser();
	}

}

3.入门案例：DI（掌握）

DI Dependency Injection ,依赖注入

isa ：是一个，继承。

hasa：有一个，成员变量，依赖。

classB {

private A a; //B类依赖A类

}

依赖：一个对象需要使用另一个对象

注入：通过setter方法进行另一个对象实例设置。

例如：

classBookServiceImpl{

//之前开发：接口 = 实现类（service和dao耦合）

//privateBookDao bookDao = new BookDaoImpl();

//spring之后（解耦：service实现类使用dao接口，不知道具体的实现类）

privateBookDao bookDao;

setter方法

}

模拟spring执行过程

创建service实例：BookService bookService = newBookServiceImpl() -->IoC <bean>

创建dao实例：BookDao bookDao = new BookDaoImple() -->IoC

将dao设置给service：bookService.setBookDao(bookDao); -->DI <property>

3.1目标类

            ~创建BookService接口和实现类
          ~创建BookDao接口和实现类
            ~将dao和service配置 xml文件

~使用api测试

3.1.1 BookDao

public interface BookDao {
	
	public void addBook();

}

public class BookDaoImpl implements BookDao {

	@Override
	public void addBook() {
		System.out.println("di  add book");
	}

}

3.1.2 BookService

public interface BookService {

	public abstract void addBook();

}

public class BookServiceImpl implements BookService {
	
	// 方式1：之前，接口=实现类
        //private BookDao bookDao = new BookDaoImpl();
	// 方式2：接口 + setter
	private BookDao bookDao;
	public void setBookDao(BookDao bookDao) {
		this.bookDao = bookDao;
	}
	
	@Override
	public void addBook(){
		this.bookDao.addBook();
	}

}

3.2配置文件

<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">
	<!-- 
	模拟spring执行过程
		创建service实例：BookService bookService = new BookServiceImpl()	IoC  <bean>
		创建dao实例：BookDao bookDao = new BookDaoImpl()			IoC
		将dao设置给service：bookService.setBookDao(bookDao);		DI   <property>
		
		<property> 用于进行属性注入
			name： bean的属性名，通过setter方法获得
				setBookDao ##> BookDao  ##> bookDao
			ref ：另一个bean的id值的引用
	 -->

	<!-- 创建service -->
	<bean id="bookServiceId" class="com.itheima.b_di.BookServiceImpl">
		<property name="bookDao" ref="bookDaoId"></property>
	</bean>
	
	<!-- 创建dao实例 -->
	<bean id="bookDaoId" class="com.itheima.b_di.BookDaoImpl"></bean>
	
</beans>

3.3测试

public class TestDI {
	
	@Test
	public void demo()
	{
		
		String xmlPath="com/itheima/b_di/beans.xml";
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
		BookService bookService=(BookService)applicationContext.getBean("bookServiceId");
		
		bookService.addBook();
	}

}

4. 装配Bean 基于XML

4.1 实例化方式 ——三种bean实例化方式：默认构造、静态工厂、实例工厂

4.1.1 默认构造

<bean id="" class=""> 必须提供默认构造

4.1.2 静态工厂

~常用于spring整合其他框架（工具）

~静态工厂：用于生成实例对象，所有的方法必须是static

4.1.2.1 工厂

public class MyBeanFactory {
	
	/**
	 * 创建实例
	 * @return
	 */
	public static UserService createService(){
		return new UserServiceImpl();
	}
}

4.1.2.2 Spring配置

	<!-- 将静态工厂创建的实例交予spring 
		class 确定静态工厂全限定类名
		factory-method 确定静态方法名
	-->
	<bean id="userServiceId" class="com.itheima.c_inject.b_static_factory.MyBeanFactory" factory-method="createService"></bean>

4.1.2.3 测试

		@Test
		public void demo01()
		{
			String xmlPath="com/itheima/c_inject/b_static_factory/beans.xml";
			ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
			UserService userService= applicationContext.getBean("userServiceId", UserService.class);
			userService.addUser();
		}

4.1.3 实例工厂
~实例工厂：必须先有工厂实例对象，通过实例对象创建对象。提供所有的方法都是“非静态”的。

4.1.3.1 工厂

/**
 * 实例工厂,所有方法非静态
 *
 */
public class MyBeanFactory {
	
	/**
	 * 创建实例
	 * @return
	 */
	public UserService createService(){
		return new UserServiceImpl();
	}

}

4.1.3.2 Spring配置

	<!-- 创建工厂实例 -->
	<bean id="myBeanFactoryId" class="com.itheima.c_inject.c_factory.MyBeanFactory"></bean>
	<!-- 获得userservice 
		* factory-bean 确定工厂实例
		* factory-method 确定普通方法
	-->
	<bean id="userServiceId" factory-bean="myBeanFactoryId" factory-method="createService"></bean>

Spring框架入门（一）——IoC、DI、装配Bean

4.2 Bean种类

~普通bean：之前操作的都是普通bean。<bean id="" class="A"> ，spring直接创建A实例，并返回

~FactoryBean：是一个特殊的bean，具有工厂生成对象能力，只能生成特定的对象。

bean必须使用 FactoryBean接口，此接口提供方法 getObject() 用于获得特定bean。

<bean id="" class="FB"> 先创建FB实例，使用调用getObject()方法，并返回方法的返回值

FB fb = new FB();

return fb.getObject();

~BeanFactory 和 FactoryBean 对比？

BeanFactory：工厂，用于生成任意bean。

FactoryBean：特殊bean，用于生成另一个特定的bean。例如：ProxyFactoryBean ，此工厂bean用于生产代理。

<bean id="" class="....ProxyFactoryBean"> 获得代理对象实例。AOP使用

4.3 作用域

作用域：用于确定spring创建bean实例个数

Spring框架入门（一）——IoC、DI、装配Bean

        ~取值：
            singleton 单例，默认值。
            prototype 多例，每执行一次getBean将获得一个实例。例如：struts整合spring，配置action多例。

~ 配置信息

<bean id="userServiceId" class="com.itheima.d_scope.UserServiceImpl" scope="prototype" ></bean>

4.4 生命周期

4.4.1 初始化和销毁

目标方法执行前和执行后，将进行初始化和销毁

4.4.1.1 目标类

public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		System.out.println("e_lifecycle add user");
	}
	
	public void myInit(){
		System.out.println("初始化");
	}
	public void myDestroy(){
		System.out.println("销毁");
	}

}

4.4.1.2 Spring配置

<!--  
		init-method 用于配置初始化方法,准备数据等
		destroy-method 用于配置销毁方法,清理资源等
	-->
	<bean id="userServiceId" class="com.itheima.e_lifecycle.UserServiceImpl" 
		init-method="myInit" destroy-method="myDestroy" ></bean>

4.4.1.3 测试

        @Test
	public void demo02() throws Exception{
		//spring 工厂
		String xmlPath = "com/itheima/e_lifecycle/beans.xml";
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		UserService userService = (UserService) applicationContext.getBean("userServiceId");
		userService.addUser();
		
		//要求：1.容器必须close，销毁方法执行; 2.必须是单例的
                //applicationContext.getClass().getMethod("close").invoke(applicationContext);
		// * 此方法接口中没有定义，实现类提供
		applicationContext.close();
		
	}

4.5 属性依赖注入

            依赖注入方式：手动装配和自动装配
            手动装配：一般进行配置信息都采用手动
                基于xml装配：构造方法、setter方法
                基于注解装配：
            自动装配：struts和spring 整合可以自动装配
                byType：按类型装配
                byName：按名称装配
                constructor：构造装配

auto：不确定装配

4.5.1 构造方法

4.5.1.1 目标类

public class User {
	
	private Integer uid;
	private String username;
	private Integer age;
	
	public User(Integer uid, String username) {
		super();
		this.uid = uid;
		this.username = username;
	}
	
	public User(String username, Integer age) {
		super();
		this.username = username;
		this.age = age;
	}

4.5.1.2 Spring配置

	<!-- 构造方法注入 
		* <constructor-arg> 用于配置构造方法一个参数argument
			name ：参数的名称
			value：设置普通数据
			ref：引用数据，一般是另一个bean id值
			
			index ：参数的索引号，从0开始 。如果只有索引，匹配到了多个构造方法时，默认使用第一个。
			type ：确定参数类型
		例如：使用名称name
			<constructor-arg name="username" value="jack"></constructor-arg>
			<constructor-arg name="age" value="18"></constructor-arg>
		例如2：【类型type 和  索引 index】
			<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
			<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
	-->
	<bean id="userId" class="com.itheima.f_xml.a_constructor.User" >
		<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
		<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
	</bean>

4.5.2 setter方法

<!-- setter方法注入 
		* 普通数据 
			<property name="" value="值">
			等效
			<property name="">
				<value>值
		* 引用数据
			<property name="" ref="另一个bean">
			等效
			<property name="">
				<ref bean="另一个bean"/>
	
	-->
	<bean id="personId" class="com.itheima.f_xml.b_setter.Person">
		<property name="pname" value="阳志"></property>
		<property name="age">
			<value>1234</value>
		</property>
		
		<property name="homeAddr" ref="homeAddrId"></property>
		<property name="companyAddr">
			<ref bean="companyAddrId"/>
		</property>
	</bean>
	
	<bean id="homeAddrId" class="com.itheima.f_xml.b_setter.Address">
		<property name="addr" value="阜南"></property>
		<property name="tel" value="911"></property>
	</bean>
	<bean id="companyAddrId" class="com.itheima.f_xml.b_setter.Address">
		<property name="addr" value="北京八宝山"></property>
		<property name="tel" value="120"></property>
	</bean>

4.5.2 集合注入

<!-- 
		集合的注入都是给<property>添加子标签
			数组：<array>
			List：<list>
			Set：<set>
			Map：<map> ，map存放k/v 键值对，使用<entry>描述
			Properties：<props>  <prop key=""></prop>  【】
			
		普通数据：<value>
		引用数据：<ref>
	-->
	<bean id="collDataId" class="com.itheima.f_xml.e_coll.CollData" >
		<property name="arrayData">
			<array>
				<value>DS</value>
				<value>DZD</value>
				<value>屌丝</value>
				<value>屌中屌</value>
			</array>
		</property>
		
		<property name="listData">
			<list>
				<value>于嵩楠</value>
				<value>曾卫</value>
				<value>杨煜</value>
				<value>曾小贤</value>
			</list>
		</property>
		
		<property name="setData">
			<set>
				<value>停封</value>
				<value>薄纸</value>
				<value>关系</value>
			</set>
		</property>
		
		<property name="mapData">
			<map>
				<entry key="jack" value="杰克"></entry>
				<entry>
					<key><value>rose</value></key>
					<value>肉丝</value>
				</entry>
			</map>
		</property>
		
		<property name="propsData">
			<props>
				<prop key="高富帅">嫐</prop>
				<prop key="白富美">嬲</prop>
				<prop key="男屌丝">挊</prop>
			</props>
		</property>
	</bean>

5.装配Bean 基于注解

~注解：就是一个类，使用@注解名称

~开发中：使用注解取代 xml配置文件。

1. @Component取代<bean class="">

@Component("id")取代 <beanid="" class="">

2.web开发，提供3个@Component注解衍生注解（功能一样）取代<beanclass="">

@Repository：dao层

@Service：service层

@Controller：web层

3.依赖注入，给私有字段设置，也可以给setter方法设置

普通值：@Value("")

引用值：

方式1：按照【类型】注入

@Autowired

方式2：按照【名称】注入1

@Autowired

@Qualifier("名称")

方式3：按照【名称】注入2

@Resource("名称")

4.生命周期

初始化：@PostConstruct

销毁：@PreDestroy

5.作用域

@Scope("prototype") 多例

~注解使用前提，添加命名空间，让spring扫描含有注解类

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">
	<!-- 组件扫描，扫描含有注解的类 -->
	<context:component-scan base-package="com.itheima.g_annotation.a_ioc"></context:component-scan>
</beans>

~例子：

Spring框架入门（一）——IoC、DI、装配Bean

注解和xml混合使用

1.将所有的bean都配置xml中

<beanid="" class="">

2.将所有的依赖都使用注解

@Autowired

默认不生效。为了生效，需要在xml配置：<context:annotation-config>

总结：

注解1：<context:component-scanbase-package=" ">

注解2：<context:annotation-config>

1.一般情况两个注解不一起使用。

2. “注解1”扫描含有注解（@Component等）类，注入注解自动生效。

“注解2”只在xml和注解（注入）混合使用时，使注入注解生效。

Spring框架入门（一）——IoC、DI、装配Bean

注解和xml混合使用

Spring入门（一）— IOC、DI

Spring基础使用（一）--------IOC、Bean的XML方式装配

Spring入门 IOC理论，第一个spring程序Di依赖注入，Bean的自动装配

spring-依赖注入(DI)&控制反转(Ioc)&Bean的三种装配方式

Spring框架入门（一）——IoC、DI、装配Bean

Spring入门（一）— IOC、DI

spring框架学习(一)——IOC/DI

【Spring学习笔记】—— （一）IOC/Bean/依赖注入DI