关于Spring的一些笔记

1 Spring是什么？

不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器（在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。

具体步骤有：

1、编写业务对象 UserDao UserService

2、配置ApplicationContext.xml

3、实例化Spring IOC

4、通过IOC使用Spring加工过的业务对象

 

以一个实例说明：

package com.aop2;

public interface IMessage {
    public void check();
}

package com.aop2;

public class Message implements IMessage {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void check() {
        System.out.println("checking " + name);
    }

}

配置beans.xml

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <bean id = "message" class = "com.aop2.Message">
        <property name = "name" value = "alvin"/>
    </bean>

</beans>

添加测试类：

package com.aop2;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "com/aop2/beans.xml");
        IMessage message1 = (IMessage)applicationContext.getBean("message");
        message1.check();
    }
}

输出：checking alvin

2 通过代理实现

上述过程并没有使用代理机制，下面使用Spring的动态代理机制实现：

更改配置类：

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <!-- 配置被代理对象 -->
    <bean id = "message" class = "com.aop2.Message">
        <property name = "name" value = "alvin"/>
    </bean>
    
    <!-- 配置代理对象 -->
    <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 代理接口集 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.aop2.IMessage</value>
            </list>
        </property>
        
        <!-- 配置被代理对象 -->
        <property name="target" ref="message" />
    </bean>

</beans>

修改测试类：

package com.aop2;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "com/aop2/beans.xml");
        IMessage message1 = (IMessage)applicationContext.getBean("proxyFactoryBean");
        message1.check();
    }
}

测试结果：checking alvin

可以看到，测试结果并没有改变，但是我们在beans.xml配置中把被代理对象message利用IOC机制放入代理对象，实现了控制的反转，在测试类中，我们将不再直接取出message类，而是通过调用动态代理类proxyFactoryBean来调用类，并取得类方法。这就揭示了Spring的思想——解耦。它是的类与类之间的耦合度降低，我们不再类中直接调用相应的方法，而是通过bean容器配置，设置必要属性的方法来使用。

3 调用多个接口

增加接口：

package com.aop2;

public interface IMessage2 {
    public void release();
}

添加property：

<property name="proxyInterfaces">
    <list>
        <value>com.aop2.IMessage</value>
        <value>com.aop2.IMessage2</value>
    </list>
</property>

测试类：

package com.aop2;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "com/aop2/beans.xml");
        IMessage message1 = (IMessage)applicationContext.getBean("proxyFactoryBean");
        IMessage2 message2 = (IMessage2)applicationContext.getBean("proxyFactoryBean");
        message1.check();
        message2.release();
    }
}

测试结果为：

checking alvin
release alvin

4 AOP

AOP是在动态代理的基础上实现的，利用InvocationHandler动态代理接口产生一个对象的代理对象，对被代理对象进行代理，以下是动态代理的实质：

public class DaiLi_DongTai {
    public static void main(String[] args) {
        IGamePlayer player = new GamePlayer("张三");
        InvocationHandler handler = new GamePlayIG(player);
        System.out.println("开始时间:" + new Date());
        ClassLoader cl = player.getClass().getClassLoader();
        IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(cl,
                new Class[] { IGamePlayer.class }, handler);
        proxy.login("zhagnsan", "password");
        proxy.killBoss();
        proxy.upgrade();
        System.out.println("结束时间:" + new Date());
    }
}

class GamePlayIG implements InvocationHandler {
    Class cls = null; //被代理者
    Object obj = null; //被代理的实例
    public GamePlayIG(Object obj) {//我要代理谁
        this.obj = obj;
    }
    //调用被代理的方法
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = method.invoke(this.obj, args);
        return result;
    }
}

5 AOP实现

加入AOP编程，这里以环绕通知为例，在方法执行的前后加入日志程序。

设定MyMethodInterceptor类：

package com.aop2;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyMethodInterceptor implements MethodInterceptor{

    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("写入日志...");
        Object object = arg0.proceed();
        System.out.println("日志完成...");
        return object;
    }
}

修改beans.xml配置：

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <!-- 配置被代理对象 -->
    <bean id = "message" class = "com.aop2.Message">
        <property name = "name" value = "alvin"/>
    </bean>
    
    <!-- 配置环绕通知 -->
    <bean id = "myMethodInterceptor" class = "com.aop2.MyMethodInterceptor"/>
    
    <!-- 配置代理对象 -->
    <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 代理接口集 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.aop2.IMessage</value>
                <value>com.aop2.IMessage2</value>
            </list>
        </property>
        
        <!-- 织入通知对象 -->
        <property name = "interceptorNames">
            <list>
                <value>myMethodInterceptor</value>
            </list>
        </property>
        
        <!-- 配置被代理对象 -->
        <property name="target" ref="message" />
    </bean>

</beans>

输出为：

写入日志...
checking alvin
日志完成...
写入日志...
release alvin
日志完成...

可以看到，在执行方法的前后，都有通知织入。