Spring初体验

Hibernate之后就迎来了Spring， ^_^ ^_^ 不过此处据说是让人看不到春天的。

Spring框架的特点：

1、 黏合剂： 面向组件开发的技术， Spring提供了对已有的各种组件技术的融合。

2、 轻量级的框架： 指应用程序基于框架开发依赖于API的严重程度低（这样子学习成本低 且 便于框架更换）。

都说学习Spring没什么新东西， 主要的就是学习一些思想。 因此今天我便开始学习了IOC思想。

IOC降低了面向对象编程对象之间的耦合度， 学习IOC主要要注意两个方面的问题：

a、 控制什么： 对象之间的依赖关系是什么

b、 反转到哪里

————IOC容器主要做了两项工作：

a、 创建对象

b、 根据对象之间的依赖关系进行注入——使用属性的get()/set()方法 或者使用构造函数。



重点是applicationContext.xml文件的配置， 多练习....



Spring & AOP ——————面向切面编程

切面： 和业务逻辑的核心实现没有关系， 但业务逻辑的实现需要某个领域提供相应的服务（如炒菜与洗菜，刷锅）。

在学习AOP时重点提到了代理模式： 代理模式的用途在于为真正的对象提供一个服务。

代理模式又分为静态代理与动态代理， 静态代理只为某一种对象提供服务， 而动态代理可以为不同类型接口类型的对象提供服务。

代理模式中存在三种角色， 分别是 真实对象、 代理对象、 一个真实对象和代理对象的接口

——————————————如下贴出我写的AOP练习 （以 洗菜——炒菜——洗碗 为例）

A、 不使用代理模式：

public class Worker {

public void beforeWork()
{
System.out.println("炒菜准备工作");
}

public void doWork()
{
beforeWork();
System.out.println("正在炒菜.....");
afterWork();
}

public void afterWork()
{
System.out.println("洗碗工作");
}
}
不使用代理模式有一个很大的弊端就是每次炒菜时都得重复地调用beforeWork()与afterWork()方法， 这样子造成了代码冗余

B、 使用静态代理模式：

CookInterface.java ——真实对象与代理对象的共同接口

public interface CookInterface {

public void doCooking();

}

CookImpl.java ——真实对象， 实现炒菜这个核心业务

public class CookImpl implements CookInterface{

public void doCooking() {
System.out.println("正在炒菜....");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}


CookProxy.java ——代理对象

public class CookProxy implements CookInterface{ //代理对象与真实对象实现同一个接口

CookInterface cooker;

public CookInterface getCooker() {
return cooker;
}

public void setCooker(CookInterface cooker) {
this.cooker = cooker;
}

public void doCooking() {
beforeWork();
cooker.doCooking();
afterWork();
}

/**
* 将为核心业务服务的方法抽取到代理对象中
*
*/
public void beforeWork(){
System.out.println("洗菜");
}

public void afterWork(){
System.out.println("洗碗");
}

}



TestAop.java ——测试类

public class TestAop {

public static void main(String[] args) {
CookInterface cooker = new CookImpl();
CookProxy cookerProxy = new CookProxy();
cookerProxy.setCooker(cooker);
cookerProxy.doCooking();
}

}

静态代理模式虽然减少了代码冗余， 但是其只能为实现某一种类型接口的特定对象提供服务



C、 动态代理： (动态代理类与测试类发生了变化， 其他两个类同上)

CookDynamicProxy.java ——动态代理类

/**
* 为不同接口类型的对象动态产生代理对象
* @author Administrator
*
*/
public class CookDynamicProxy implements InvocationHandler{

private Object targetObject; //真实对象
/**
* 动态产生代理对象
*/
public Object createProxyObject(Object targetObject){
this.targetObject = targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(), this);

}

/**
* 提供代理的服务(切面)
* proxy是代理对象
* method是代理对象调用的方法
* args是调用方法的实参列别
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeWork();
//调用真实对象的方法
Object result = method.invoke(targetObject, args);
afterWork();
return result;
}

public void beforeWork(){
System.out.println("洗菜");
}

public void afterWork(){
System.out.println("洗碗");
}

}



TestDynamicProxy.java

public class TestDynamicProxy {

public static void main(String[] args) {
CookInterface cooker = new CookImpl();
CookInterface cookerProxy = (CookInterface)new CookDynamicProxy().createProxyObject(cooker);
cookerProxy.doCooking();
}

}

这样子就与具体的接口解耦了。 ^_^ ^_^ 这是一种比较好的做法。



D、 在Spring中使用动态代理模式， 通过配置appicationContext.xml以及调用Spring API的方式实现

这种方式主要是配置applicationContext.xml， 如下是我的配置：

<!-- 配置真实对象 -->
<bean id="realWorker" class="cn.com.aop.CookImpl"></bean>
<!-- 配置通知 -->
<bean id="arroundNote" class="cn.com.aop.ArroundLog"></bean>
<!-- 配置动态代理 -->
<bean id="workProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 指定要实现的接口 -->
<property name="interfaces"><value>cn.com.aop.CookInterface</value></property>
<!-- 指定代理的真实对象 -->
<property name="target" ref="realWorker"></property>
<!-- 指定运行时织入的通知 -->
<property name="interceptorNames">
<list>
<value>arroundNote</value>
</list>
</property>
</bean>

关于源文件只有如下两个与上面的源文件不同， 列举如下：

ArroungLog.java ——通知

/**
* 切面代码,在方法的前后进行织入
* @author Administrator
*
*/
public class ArroundLog implements MethodInterceptor {

public Object invoke(MethodInvocation arg0) throws Throwable {
beforeWork();
Object result = arg0.proceed();
afterWork();
return result;
}

public void beforeWork(){
System.out.println("洗菜");
}

public void afterWork(){
System.out.println("洗碗");
}
}

Test.java ——测试类

public class Test {
public static void main(String[] args) {
Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resource);
CookInterface cooker = (CookInterface)bf.getBean("workProxy");
cooker.doCooking();


}

}