Spring In Action 学习 第一章 Spring之旅

Spring的目标：简化Java开发。

四种策略：

1.基于POJO的轻量级的最小侵入性编程。

2.通过依赖注入和面向接口实现松耦合。

3.基于切面和惯例进行声明式编程。

4.通过切面和模块减少样板式代码。

练习源码：1. 骑士接口 Knight.java

package org.yuanbin.test;
/**
 * 骑士接口
 * @author huang-yuanbin
 *
 */
public interface Knight {
	/**
	 * 执行各种任务
	 */
	void embarkOnQuest();
}

练习源码：2. 探索任务接口 Quest.java

package org.yuanbin.test;
/**
 * 探险任务接口
 * @author huang-yuanbin
 *
 */
public interface Quest {
	void embark();
}

练习源码：3. 骑士实现 BraveKnight.java

package org.yuanbin.test;
/**
 * 骑士实现
 * @author huang-yuanbin
 *
 */
public class BraveKnight implements Knight {
	private Quest quest;
	@Override
	public void embarkOnQuest() {
		// TODO Auto-generated method stub
		quest.embark();
	}
	public BraveKnight(Quest quest) {
		this.quest =quest;
	}

}

练习源码：4. Mockito框架测试类

需添加Mockito依赖

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>1.10.19</version>
</dependency>

package org.yuanbin.test;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import org.junit.Test;
/**
 * Mockito框架测试类
 * @author huang-yuanbin
 *
 */
public class BraveKnightTest {
	@Test
	public void KnightShouldEmbarkOnQuest() {
		//模拟的创建，对接口进行模拟
		Quest mockQuest =mock(Quest.class);
		BraveKnight knight =new BraveKnight(mockQuest);
		knight.embarkOnQuest();
		//验证Quest接口的方法
		verify(mockQuest,times(1)).embark();
	}
}

练习源码：5. 探险任务实现 SlayDragonQuest.java

package org.yuanbin.test;

import java.io.PrintStream;

/**
 * 探险任务实现
 * 
 * @author huang-yuanbin
 *
 */
public class SlayDragonQuest implements Quest {
	private PrintStream stream;

	@Override
	public void embark() {
		// TODO Auto-generated method stub
		stream.println("击杀恶龙");
	}

	public SlayDragonQuest(PrintStream stream) {
		// TODO Auto-generated constructor stub
		this.stream = stream;
	}

}

练习源码：6. xml装配

创建xml配置文件方式：项目右键 -》New -》Other -》Spring Bean Configuration File

<?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-2.0.xsd">
	<!-- 注入Quest bean -->
	<bean id="Knight" class="org.yuanbin.test.BraveKnight">
		<constructor-arg ref="quest"></constructor-arg>
	</bean>
	<!-- 创建SlayDragonQuest -->
	<bean id="quest" class="org.yuanbin.test.SlayDragonQuest">
		<constructor-arg value="#{T(System).out}"></constructor-arg>
	</bean>
</beans>

练习源码： 7. java装配

package org.yuanbin.test;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class KnightConfig {
	@Bean
	public Knight knight() {
		return new BraveKnight(quest());
	}

	@Bean
	public Quest quest() {
		return new SlayDragonQuest(System.out);
	}
}

练习源码：8 执行Main方法

package org.yuanbin.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 执行骑士探险
 * 
 * @author huang-yuanbin
 *
 */
public class KnightMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 加载Spring上下文
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("knights.xml");
		// 获取Knight的Bean
		Knight knight = context.getBean(Knight.class);
		// 使用Knight
		knight.embarkOnQuest();
		context.close();
	}

}

 

练习源码： 9. 呤游诗人类 Minstrel.java

package org.yuanbin.test;

import java.io.PrintStream;

/**
 * 呤游诗人类
 * 
 * @author huang-yuanbin
 *
 */
public class Minstrel {
	private PrintStream printStream;

	public Minstrel(PrintStream printStream) {
		// TODO Auto-generated constructor stub
		this.printStream = printStream;
	}

	public void singleBefore() {
		printStream.println("探险前调用");
	}

	public void singleAfter() {
		printStream.println("探险后调用");
	}
}

练习源码：10.将Minsterl声明为一个切面

添加aop依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>3.2.5.RELEASE</version>
</dependency>

<?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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
	<!-- 注入Quest bean -->
	<bean id="Knight" class="org.yuanbin.test.BraveKnight">
		<constructor-arg ref="quest"></constructor-arg>
	</bean>
	<!-- 创建SlayDragonQuest -->
	<bean id="quest" class="org.yuanbin.test.SlayDragonQuest">
		<constructor-arg value="#{T(System).out}"></constructor-arg>
	</bean>
	<!-- 创建Minstrel -->
	<bean id="minstrel" class="org.yuanbin.test.Minstrel">
		<constructor-arg value="#{T(System).out}"></constructor-arg>
	</bean>

	<aop:config>
		<aop:aspect ref="minstrel">
			<!-- 定义切点 -->
			<aop:pointcut
				expression="execution(* *.embarkOnQuest(..))" id="embark" />
			<!-- 声明前置通知 -->
			<aop:before pointcut-ref="embark" method="singleBefore" />
			<!-- 声明后置通知 -->
			<aop:after pointcut-ref="embark" method="singleAfter" />
		</aop:aspect>
	</aop:config>
</beans>

运行结果：

使用应用上下文

Spring自带的多种类型的应用上下文：

1. AnnotationConfigApplicationContext: 从一个或多个基于Java的配置类中加载Spring应用上下文。

2. AnnotationConfigWebApplicationContext: 从一个或多个基于Java的配置类中加载Spring Web应用上下文。

3. ClassPathXmlApplicationContext: 从类路径下的一个或多个XML配置文件中加载上下文定义，将应用上下文的定义文件作为类资源。

4. FileSystemXmlapplicationcontext: 从文件系统下的一个或多个XML配置文件中加载上下文定义。

5. XmlWebApplicationContext: 从Web应用下的一个或多个XML配置文件中加载上下文定义。

Bean生命周期

1. Spring对bean进行实例化。

2. Spring将值和bean的引用注入到bean对应的属性中。

3. 如果bean实现BeanNameAware接口，Spring将bean的ID传送给setBean-Name()方法。

4. 如果bean实现BeanFactoryAware接口， Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入。

5. 如果beana实现ApplicationContextAware接口，Spring将调用setApplicationContext()方法，将bean所在应用上下文的引用传入进来。

6. 如果bean实现BeanPostProcessor接口，Spring将调用它们的Post-ProcessBeforeInitialization()方法。

7. 如果bean实现了InitializingBean接口，Spring将调用它们的after-PropertiesSet()方法。类似地，如果bean使用init-method声明了初始化方法，该方法也会被调用。

8. 如果bean实现了BeanPostProcessor接口，Spring将调用它们的Post-ProcessAfterInitization()方法。

9. 此时，bean已经准备就绪，可以被应用程序使用了，它们将一直驻留在应用上下文中，直到该应用上下文被销毁。

10. 如果bean实现了DisposableBean接口，Spring将调用它的destroy()接口方法。同样，如果Bean使用destroy-method声明了销毁的方法，该方法也会被调用。