Spring Day01（20211008）

一.概念

Spring是一种开源的轻量级javaEE框架，解决业务逻辑层与其他各层的松耦合问题。

1.特征

• 轻量
• 容器
• 框架
• IoC/DI
  (Inversion of Control)控制反转/（Dependency Injection）依赖注入；
  控制反转LoC是一种设计思想，依赖注入DI是实现IoC的一种方法；
  AOP
  （Aspect Oriented Programming）面向切面编程

2.组成

• 核心容器
  BeanFactory：它是工厂模式的实现。
  Application Context：使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开（一个xml文件）。

• Spring AOP
  基于 Spring 的应用程序中的对象提供了事务管理服务。

• Spring DAO

• Spring Web

二.IoC容器

Spring就是一个IoC容器，利用该容器管理对象之间的关系，Spring框架的基本思想就是控制反转。

2.1 概念

• 在IoC模式下，控制权限从应用程序转移到IoC容器中；
• 组件不是由应用程序创建和配置，而是由IoC容器负责；
• 使用IoC的情况下，对象是被动地接收依赖类而不是主动地查找；
• 应用程序只需要直接使用已经创建并且配置好的组件即可，而不必自己创建和配置。

2.2 LoC容器

2.3 Bean

2.3.1 Simple Object

2.3.2 Spring中的Bean

1.定义在配置文件（applicationContext.xml）中

格式：<bean id="" class=""></bean>

<bean id="mb" class="com.dr.s1.MyBean"/>

2.实例化的三种方式（重点）

• 构造器实例化

MyBean.java

public class MyBean {
	private String name;

	MyBean(String name) {
		this.name = name;
	}

	public void test() {
		System.out.println(name);
		System.out.println("MyBean----test");
	}
}

applicationContext.xml

		<!-- 1.通过构造器实例化Bean -->
		<bean id="mb" class="com.dr.s1.MyBean">
			<constructor-arg type="String" value="Jack"></constructor-arg>
		</bean>

• 静态工厂方法实例化

StaticFactory.java
说明：包含静态方法createBean（）

public class StaticFactory {
	public static MyBean createBean() {
		return new MyBean("static factory");
	}
}

applicationContext.xml

		<!-- 2.通过静态工厂方法实例化Bean -->		
		<bean id="mb2" class="com.dr.s1.StaticFactory" factory-method="createBean"/>

• 实例工厂方法实例化

InstanceFactory.java
说明：getInstance()方法获取MyBean的实例

public class InstanceFactory {
	public MyBean getInstance() {
		return new MyBean("instance factory");
	}
}

applicationContext.xml

		<!-- 3.通过实例工厂方法实例化Bean -->
		<bean id="iff" class="com.dr.s1.InstanceFactory"/><!-- 创建InstanceFactory对象 -->
		<bean id="mb3" factory-bean="iff" factory-method="getInstance"/>

实例化Bean测试类 SpringTest.java

public class SpringTest {
    public static void main(String[] args) {
    	
        BeanFactory bf= new ClassPathXmlApplicationContext("applicationContext.xml");
        
        //Spring 构造器
        MyBean mb1 = (MyBean) bf.getBean("mb");
        mb1.test();

        //java 静态工厂方法
        //MyBean mb2 = StaticFactory.createBean();
       
        //Spring 静态工厂方法
        MyBean mb2 = (MyBean) bf.getBean("mb2");
        mb2.test();
        
        //java 实例工厂方法
        //InstanceFactory iff = new InstanceFactory();
        //MyBean mb3 = iff.getInstance();
        
        //Spring 实例工厂方法
        MyBean mb3 = (MyBean) bf.getBean("mb3");
        mb3.test();
        
    }
}

测试结果：

3.常用属性

• init-method:指定初始化方法
• destroy-method:指定销毁方法

applicationContext.xml

		<!-- 指定MyBean中的init()方法为初始化方法 -->
		<!-- 指定MyBean中的destory()方法为销毁方法 -->
		<bean id="bean" class="com.dr.s2.MyBean"
		init-method="init"
		destroy-method="destory"/>

MyBean.java

public class MyBean {

	public MyBean() {
		System.out.println("构造方法");
	}
    
	public void init() {
		System.out.println("init");
	}
	public void test()  {
		System.out.println("test");
	}
	public void destory()  {
		System.out.println("destory");
	}
    
}

属性测试类 SpringTest.java

public class SpringTest {
	public static void main(String[] args) {
        AbstractApplicationContext bf= new ClassPathXmlApplicationContext("applicationContext.xml");
        MyBean mb = (MyBean) bf.getBean("bean");
        mb.test();
        bf.close();

• lazy-init:延迟加载

applicationContext.xml

		<!-- lazy-init默认(default=false) -->
		<bean id="lazy" class="com.dr.s2.LazyBean"
		lazy-init="true"/>

LazyBean.java

public class LazyBean {
	public LazyBean() {
		System.out.println("LazyBean构造器");
	}	
}

属性测试类 SpringTest.java

public class SpringTest {
	public static void main(String[] args) {
	BeanFactory bf = new ClassPathXmlApplicationContext("applicationContext.xml");
	bf.getBean("lazy");

结果说明：
 在lazy-init="true"时，
	只有当下面的getBean()方法被调用时，LazyBean的构造方法才执行；
	当下面的getBean()方法不被调用，LazyBean的构造方法则不执行；
 在lazy-init="false" 或 lazy-init="default"时，
	无论下面的getBean()方法被调用时，LazyBean的构造方法都会执行；

• scope:设置Bean的作用域
  

MyBean.java

public class MyBean {
	
}

applicationContext.xml

		<bean id="bean1" class="com.dr.s3.MyBean" scope="singleton"/>
		<bean id="bean2" class="com.dr.s3.MyBean" scope="prototype"/>

public class SpringTest {
	public static void main(String[] args) {

		BeanFactory bf = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		MyBean bean1 = (MyBean) bf.getBean("bean1");
		MyBean bean2 = (MyBean) bf.getBean("bean1");

		MyBean bean3 = (MyBean) bf.getBean("bean2");
		MyBean bean4 = (MyBean) bf.getBean("bean2");

	}
}

结果说明：
	bean1,bean2是同一对象;
	bean3,bean4不是同一对象;