Spring Ioc/DI 依赖注入 与 aop 面向切面编程（前置、后置增强） 简单应用

1.在项目中添加Spring AOP相关的 jar包
创建HelloSpring类

/**
 *
 */
public class HelloSpring {
    // 定义name属性，该属性的值将通过Spring框架进行设置
    private String name;

     /**
     * 定义打印方法，输出一句完整的问候。
     * @param str
     * @return
     */
    public Integer print(String str){
        System.out.println("实现注入：hello"+this.name);
        //返回一个参数，这里返回固定值“100”(为了体现后置增加的效果)
        return 100;
    }

    public String getInfo() {
        return name;
    }

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

2.编写前置增强和后置增强实现日志功能
为了能够在增强方法中获得当前连接点的信息，以遍实施相关的判断和处理，
可以在增强方法中声明一个Joinpoint（连接点）类型的参数，spring会自动注入实例。
通过getTarget()得到被代理的目标对象，
通过getSignature()返回被代理的目标方法，
还可以通过getArgs()获得传递给目标方法的参数数组。
对于实现后置增强的afterReturning（）方法，还可以定义一个参数用于接收目标方法的返回值。

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;

import java.util.Arrays;

/**
 * 定义包含增强方法的JavaBean
 */
public class SpringBeforAdvice {
   
   
    /**
     * 前置增强方法
     * @param joinpoint
     */
    public void befor(JoinPoint joinPoint){

      System.out.println("调动"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()
                +"方法。方法入参："+ Arrays.toString(joinPoint.getArgs()));
    }

    /**
     * 后置增强方法
     * @param joinPoint
     * @param result
     */
    public void afertReturning(JoinPoint joinPoint,Object result){
        System.out.println("调动"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()
                +"方法。方法返回值："+result);
    }
}

3.编写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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
    <!-- 通过bean元素声明需要Spring创建的实例。该实例的类型通过class属性指定，并通过id属性为该实例指定一个名称，以便在程序中使用 -->
    <bean id="helloSpring" class="cn.spring.day01.HelloSpring">
        <!-- property元素用来为实例的属性赋值,此处实际是调用setInfo()方法实现赋值操作 -->
        <property name="info" value="Spring"/>
    </bean>

    <!-- 声明增强方法所在的Bean -->
    <bean id="theLogger" class="cn.spring.day01.aop.SpringBeforAdvice"></bean>
    <!-- 配置切面 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut id="pointcut" expression="execution(* cn.spring.day01.HelloSpring.*(..))"/>
        <!-- 引用包含增强方法的Bean -->
        <aop:aspect ref="theLogger">
            <!-- 将before()方法定义为前置增强并引用pointcut切入点 -->
            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
            <!-- 将afterReturning()方法定义为后置增强并引用pointcut切入点 -->
            <!-- 通过returning属性指定为名为result的参数注入返回值 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
        </aop:aspect>
    </aop:config>
</beans>

4.编写代码(测试类)，获取带有增强处理的业务对象

import cn.spring.day01.HelloSpring;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void test() {
        // 通过ClassPathXmlApplicationContext实例化Spring的上下文
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过ApplicationContext的getBean()方法，根据id来获取bean的实例
        HelloSpring helloSpring = (HelloSpring) context.getBean("helloSpring");
        // 执行print()方法（有参数）
        helloSpring.print("Param");
    }
}

运行结果：