目录
1.开始Spring之旅(简介)
2.装配Bean(IoC)
3.创建切面(AOP)
。。。
第一章：开始Spring之旅
1.1 为什么使用Spring：简化了企业级系统开发。
1.1.1 javaEE开发者的一天：EJB功能强大，即使简单的应用系统都需要各种组件的支持，使用较为复杂。
1.1.2 Spring的承诺：
1.好的设计比实现技术更重要
2.通过接口松散耦合的JavaBean是一个很好的模型
3.代码应该容易被测试
1.2 Spring是什么：Spring是一个轻量级的IOC和AOP容器框架
轻量级：1MB多的jar包源代码
非侵入式：基于Spring开发系统中的对象一般不依赖于Spring框架中的类
反向控制：创建一个对象时，需要在容器系统中寻找所对应的类，而反向控制，则是在容器启动实例化时，主动为引用的实例类注入依赖类对象
面向切面：提取多种业务的共性，形成一种过滤效果，使开发者只需要关注具体的逻辑业务问题
容器：可以管理系统中对象的生命周期与设置(BeanFactory/ApplicationContext)
框架：通过XML文件配置组合
spring组成模块：
1.3 开始Spring之旅
//接口定义 package com.cys.test;
public interface GreetingService { public void sayGreeting(); }
//具体实现类 package com.cys.test; public class GreetingServiceImpl implements GreetingService { private String greeting; public GreetingServiceImpl() {} public GreetingServiceImpl(String greeting) { this.greeting = greeting; } public void sayGreeting() { System.out.println("GreetingServiceImpl [greeting=" + greeting + "]"); } public void setGreeting(String greeting) { this.greeting = greeting; } }
//主函数类 package com.cys.test; import java.io.FileInputStream; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; public class HelloApp{ public static void main(String[] args) throws Exception{ BeanFactory factory = new XmlBeanFactory(new FileInputStream("spring-beans.xml")); GreetingService greeting = (GreetingService)factory.getBean("greetingService"); greeting.sayGreeting(); } }
<?xml version="1.0" encoding="UTF-8"?> <!-- xml配置文件 --> <beans> <!-- 无参数构造 --> <bean id="greetingService" class="com.cys.test.GreetingServiceImpl"> <property name="greeting" value="Hello World" /> </bean> <!-- 带参数构造 --> <bean id="greetingService" class="com.cys.test.GreetingServiceImpl"> <constructor-arg> <value>Hello World</value> </constructor-arg> </bean> </beans>
1.4 理解反向控制（依赖注入）：获得依赖对象的方式反转
1.5 应用AOP：IoC使软件组件松散连接成为可能，AOP让你能够捕捉经常使用的功能，把该功能转化为组件
1.6 Spring比较
小结：
第二章：装配Bean
2.1 容器是Spring框架的核心：BeanFactory、ApplicationFactory
2.1.1 BeanFactory：Bean简单工厂管理模式
常见实现类：XmlBeanFactory
BeanFactory factory = new XmlBeanFactory(new FileInputStream("beans.xml"));
MyBean myBean = factory.getBean("myBeanId");
2.1.2 ApplicationFactory:提供更多附加的功能(文本信息解析工具、载入文件资源、注册监听器)
常见实现类：ClassPathXmlApplicationFactory、FileSystemXmlApplicationFactory、XmlWebApplicationFactory
ApplicationFactory factory = new ClassPathXmlApplicationFactory("beans.xml");
ApplicationFactory factory = new FileSystemXmlApplicationFactory("c:/beans.xml");
XmlWebApplicationFactory：见第八章
2.1.3 Bean生命周期
Bean工厂容器与ApplicationContext容器的唯一区别：ApplicationContext容器会调用ApplicationContextAware接口的setApplicationContext()方法
2.2 基本配置（Beans.xml）
2.2.1 xml配置：<beans><bean id="" class=""/><beans ...></beans>
2.2.2 添加一个Bean
bean属性：
单实例与原型：singleton="true"--单实例(默认) singleton="false"--原型(每次getBean(),获取的对象都是一个新的)
实例化与销毁：init-method="name1"--初始化时调用name1()方法 destroy-method="name2"--销毁时调用name1()方法
2.2.3 set属性注入
基本类型注入(int、String、...)：<property name="xxx"><value>xxx(值)</value></property>
引入其他bean：<property name="xxx"><ref bean="xxx(beanId)"></property>(常用)、<property name="xxx"><bean class="" /></property>(不常用)
List与数组：<property name="xxx"><list><value>xxx(值)</value><ref ...><...></list></property>(值可以是任意元素)
Set：<property name="xxx"><set><value>xxx(值)</value><ref ...><...></set></property>(值可以是任意元素)
Map：<property name="xxx"><map><entry key="xxx1"><value>xxx(值)</value></entry><entry key="xxx2"><ref ...></entry><entry key="..."><...></entry></map></property>(值可以是任意元素)
Property：<property name="xxx"><prop key="xxx1">xxx(值)</prop><prop key="xxx2">xxx(值)</prop>...</property>(值只能是String类型，不需要<value>标签)
设置null：<property name="xxx"><null/></property>(默认可以不设置，这是显示装配)
2.2.4 构造函数注入
与set同理，<property>改为<constructor-arg>，并提供了index、tyep属性
index：参数序号，从0开始--<constructor-arg index="0"><value><ref ...>...</constructor-arg>
type：属性类型(java.lang.String)--<constructor-arg type="java.lang.String"><value><ref ...>...</constructor-arg>
默认情况可以不设置，在多个参数类型相同时，为区分参数先后顺序，必须设置index属性
set注入与构造函数注入区别：构造函数可以强制关联依赖关系，达到初始化一个完整可用的对象
2.3 自动装配Bean（一般不考虑）
。。。
2.4 特殊bean：实现spring特定的接口，在bean生命周期的过程中处理bean信息
2.4.1 对bean进行后处理：实例化后初始化前--初始化后
接口：BeanPostProcessor
覆盖方法(实例化后初始化前方法)：postProcessBeforeInitialization(Object bean, String name)
覆盖方法(初始化后方法)：postProcessAfterInitialization
注册bean：
Bean工厂容器：factory.addBeanPostProcssor(BeanPostProcessor接口类的实现类)
上下文容器：在xml配置文件里添加实现BeanPostProcessor接口的类bean即可，上下文容器会自动识别：<bean id="" class="" />
spring框架自动BeanPostProcessor实现
。。。
2.4.2 对Bean工厂进行后处理：实例化之前，即容器加载bean配置文件定义，开始实例化每个bean之前
接口：BeanFactoryPostProcessor
覆盖方法(实例化之前)：postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
2.4.3 分散配置：Spring容器定义bean信息集中在一个配置文件里，不利于维护和修改，容易形成硬性编码
ApplicationContext上下文容器自带引用加载properties类型文件实现类：PropertyPlaceholderConfigurer
在xml配置文件里添加以下代码，加载属性，可以使用${key}来获取properties属性文件所对应的值
<bean id="xxx" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location">
<value>xxx.properties</value>
<value>...</value>
<property>
</bean>
2.4.4 属性类型编辑器：对参数值类型转换接收
。。。
2.4.5 解析文本信息
。。。
2.4.6 监听事件：ApplicationContext容器在生命周期中默认会触发许多事件
触发事件：ContextCloseEvent--应用上下文关闭时触发 ContextRefreshedEvent--应用上下文初始化或刷新时触发 RequestHandledEvent--Web服务应用上下文中请求被处理后触发
这个三个事件类都是抽象类org.springframework.context.ApplicationEvent的子类
监听事件处理：实现org.springframework.context.ApplicationListener接口，实现onApplicationEvent方法，并在spring配置文件里注册bean
2.4.7 设置触发事件
。。。
2.4.8 感知bean：用于获取bean属性信息
常用接口：BeanNameAware--获取beanID BeanFactoryAware--获取bean容器 ApplicationContextAware--获取bean容器
bean类实现BeanNameAware接口，获取beanID值
//声明属性，设置属性值，注册bean后，自动加载属性赋值
public class GetBeanName implements BeanNameAware{
private String beanName;
public void setBeanName(String beanName){
this.beanName = beanName;
}
}
bean类实现BeanFactoryAware接口，获取容器
//声明属性，设置属性值，注册bean后，自动加载属性赋值
public class GetBeanFactory implements BeanFactoryAware{
private BeanFactory factory;
public void setBeanFactory(BeanFactory factory){
this.factory= factory;
}
}
bean类实现ApplicationContextAware接口，获取容器
//声明属性，设置属性值，注册bean后，自动加载属性赋值
public class GetBeanFactory implements ApplicationContextAware{
private ApplicationContext context;
public void setApplicationContext(ApplicationContext context){
this.context = context;
}
}
第三章：创建切面
3.1 AOP介绍
3.1.1 定义AOP术语：切面（Aspect）、连接点（Joinpotion）、通知（Advice）、切入点（Pointcut）、引入（Introduction）、目标对象（Target）、代理（Proxy）、织入（Weaving）
3.2.2 Spring的AOP实现
。。。
3.2 创建通知
3.2.1 前置通知：目标方法前执行
//创建通知实体类，实现前置通知接口，复写接口方法 public class WelcomeAdvice implements MethodBeforeAdvice{ //Method：目标方法 //args：目标方法参数列表 //target：目标对象 public void before(Method method, Object[] args, Object target){ //具体通知逻辑业务 } }
<!-- 配置文件 --> <bean id="xxx1" class="目标对象" /> <bean id="xxx2" class="具体通知对象"> <bean id="xxx3" class="org.springframework.aop.framework.ProxyFactoryBean(代理对象)"> <property name="proxyInterfaces(目标对象实现的接口类)"> <value>xxx.xxxxx.xxxx.xxx4</value> </property> <property name="interceptorNames(通知列表)"> <list> <value>xxx2</value> ... </list> </property> <property name="target(目标对象)"> <value>xxx1</value> </property> </bean>
3.2.2 后置通知：目标方法后执行
//创建通知实体类，实现后置通知接口，复写接口方法 public class ThankYouAdvice implements AfterReturningAdvice{ //returnValue：目标方法的返回值 //Method：目标方法 //args：目标方法参数列表 //target：目标对象 public void afterReturning(Object returnValue, Method method, Object[] args, Object target){ //具体通知逻辑业务 } }
3.2.3 环绕通知：目标方法前后都行，但需要手动调用目标方法并返回值
//创建通知实体类，实现环绕通知接口，复写接口方法 public class OnePerCustomerInterceptor implements MethodInterceptor{ //MethodInterceptor：封装目标对象相关类 public Obeject invoke(MethodInvocation invocation){ //手动调用目标方法，返回目标方法返回值 Obeject xxx = invocation.proceed(); //手动返回 return xxx; } }
3.2.4 异常通知：调用目标方法抛出异常时执行
实现ThrowsAdvice接口，并覆盖void afterThrowing(Throwable throwable)与void afterThrowing(Throwable throwable, Method method, Object[] args, Object target)任意一个方法
3.2.5 引入通知：给目标对象添加行为或属性
。。。
3.3 定义切入点：定义通知在那些地方应用
3.3.1 在Spring中定义切入点
//切入点核心接口 public interface Poincut{ //类过滤 ClassFilter getClassFilter(); //方法过滤 MethodMatcher getMethodMatcher(); }
//类过滤接口 public interface ClassFilter{ //根据类名过滤 boolean maches(Class clazz); }
//方法过滤接口 public interface MethodMatcher{ //判断是否目标方法是否需要通知 boolean maches(Method m, Class targetClass); //如果maches返回true，则调用判断是静态通知还是动态通知 public boolean isRuntime(); //只有isRuntime返回true，则为动态通知，才会执行以下方法 public boolean maches(Method m, Class targetClass, Object[] args); }
提示：尽量使用静态通知，动态通知对性能会有消耗
3.3.2 理解Advisor：通知与切入点整合接口类
//Advisor接口 public interface PointcutAdvisor{ //获取切入点类 Pointcut getPointcut(); //获取通知类 Advice getAdvice(); }
3.3.3 使用Spring的静态切入点
父类：StaticMethodMatcherPointcut
常用子类(名称映射)：NameMatchMethodPointcut
映射方法：public void setMappedName(String), public void setMappedName(String[]);
配置NameMatchMethodPointcut类型切入点：
<beans> <bean id="xxx1" class="(目标实例类)"/> <bean id="xxx2" class="(通知类)"/> <!-- 定义切入点 --> <bean id="xxx3" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor"> <!-- 定义通知切入的规则 --> <property name="mappedName"> <value>order*</value> <!-- 不适用通配符，指定具体切入方法 <list> <value>orderxxx1</value> <value>orderxxx2</value> </list> --> </property> <!-- 绑定切入点的通知 --> <property name="advice"> <ref bean="xxx2" /> </property> </bean> <!-- 切面代理类 --> <bean id="xxx4" class="org.springframework.aop.framework.ProxyFactoryBean(代理对象)"> <property name="proxyInterfaces(目标对象实现的接口类)"> <value>xxx.xxxxx.xxxx.xxx5</value> </property> <property name="interceptorNames(通知列表)"> <list> <value>xxx3</value> ... </list> </property> <property name="target(目标对象)"> <value>xxx1</value> </property> </bean> </beans>
规则表达式切入点：RegexpMethodPointcut
配置RegexpMethodPointcut类型切入点：
<beans> <bean id="xxx1" class="(目标实例类)"/> <bean id="xxx2" class="(通知类)"/> <!-- 定义切入点 --> <bean id="xxx3" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <!-- 定义通知切入的规则 --> <property name="pattern"> <!-- 定义通知切入的规则:所有类以get开头，后面至少有一个字符，接着有By，再后面至少有一个字符 --> <value>.*get.+By.+</value> </property> <!-- 绑定切入点的通知 --> <property name="advice"> <ref bean="xxx2" /> </property> </bean> <!-- 切面代理类 --> <bean id="xxx4" class="org.springframework.aop.framework.ProxyFactoryBean(代理对象)"> <property name="proxyInterfaces(目标对象实现的接口类)"> <value>xxx.xxxxx.xxxx.xxx5</value> </property> <property name="interceptorNames(通知列表)"> <list> <value>xxx3</value> ... </list> </property> <property name="target(目标对象)"> <value>xxx1</value> </property> </bean> </beans>
3.3.4 动态切入点
。。。
3.3.5 切入点合并与交叉：通过切入点与切入点、对象、方法、等等的组合与交集形成新的切入点，创建一个实体类，编写参数切入点组合，通过属性配置bean注入切入点参数
1.编写切入点组合工具类
//编写组合代码工具类 public class UnionPointcut implements Pointcut{ //声明合并的Pointcut实例 private Pointcut delegate; //接口方法 public ClassFilter getClassFilter(){ return getDelegate().getClassFilter(); } public MethodMatcher getMethodMatcher(){ return getDelegate().getMethodMatcher(); } //声明异常 private Pointcut getDelegate(){ if(delegate == null){ throw new AopConfigException("No pointcuts have configured."); } return delegate; } //组合切入点的逻辑代码 public void setPointcuts(List pointcuts){ if(pointcuts == null || pointcuts.size() == 0){ throw new AopConfigException("Must have at least one Pointcut."); } } delegate = (Pointcut)pointcuts.get(0); for(int i = 1; i<pointcuts.size(); i++){ Pointcut pointcut = (Pointcut)pointcuts.get(i); delegate = Pointcuts.union(delegate, pointcut); } }
配置<bean id="xxx" class="xxx.xxx.UnionPointcut"><property name="pointcuts"><Lits><value>xxx</value>...</List></property></bean>
2.编写切入点交集工具类：
。。。
3.4 创建引入切面：对已有的实体类添加行为或属性
。。。
3.5 ProxyFactoryBean详解
常用属性：target、proxyInterfaces、interceptorNames
3.6 自动代理：BeanNameAutoProxyCreator、DefaultAutoProxyCreator
BeanNameAutoProxyCreator可以的代理类型：切入点、通知、拦截器，DefaultAutoProxyCreator只能代理切入点（Advisor）
BeanNameAutoProxyCreator配置
<bean id="xxx1" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames"> <list> <!-- 正则表达式 --> <value>*Service</value> </list> </property> <property name="interceptorNames"> <value>xxx(切入点、通知、拦截器)</value> </property> </bean>
DefaultAutoProxyCreator配置：
<bean id="xxx1" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice"> <ref bean="xxx2(通知)"> </property> <property name="pattern"> <value>.+Service..+</value> </property> </bean> <!-- 自动代理Advisor通知 --> <bean id="xxx3" class="org.springframework.aop.framework.autoproxy.DefaultAutoProxyCreator"/>
