Spring基础---配置文件、Ioc、AOP

一、 需要的基础jar包

这里显示的是基础的jar包 , 后续你需要什么还应继续添加
MyEclipse可以一键导入自带的jar —–>项目名右键>MyEclipes>Add Spring……

二、 核心思想—>控制反转(依赖注入)

在项目中添加Spring的配置文件--->applicationContent.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">


</beans>

   比如我们想在B类的方法中实例化了A类的对象并调用其方法完成特定的功能这样的情况我们就可以说B类依赖A类;这样不利于降低代码之间的耦合度,利用Spring 我们可以实现控制反转,即在B类中不在依赖A类去获得具体的实例,而是把这个工作交给第三方,实现了控制反转.

更加利于实现面向接口编程, 只需要知道有这个接口,不需要在意这个接口是如何实现,降低代码耦合

这里有个简单的实体类 —>纸张类,如何使用Spring实现依赖注入呢?
在application中添加一段代码

<!-- id表示当前文件的唯一标示  class=""表示"<bean>"标签对应的类 -->
<bean id="A4" class="paper.TextPaper">
        <!-- "property"对应类的属性  "name"表示对应哪个具体的属性  value是值 -->
        <property name="lineCountChar" value="5"></property>
        <property name="lineInPage" value="10"></property>
    </bean>

利用下面的代码可以获取类型为 “paper.TextPaper”的对象和注入的对象的属性,实现控制反转

/*
 *import org.springframework.context.ApplicationContext;
 *import org.springframework.context.support.ClassPathXmlApplicationContext;
 */

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
TextPaper paper =(TextPaper) ac.getBean("A4");

如何注入复杂类型的数据呢?

例如 打印机类有墨盒类型和纸张类型的属性, 需要在 “bean”标签中如何配置呢

    <!-- 配置纸张 -->
    <bean id="A4" class="paper.TextPaper">
        <property name="lineCountChar" value="5"></property>
        <property name="lineInPage" value="10"></property>
    </bean>

    <!-- 配置打印机 -->
    <bean id="print" class="entity.Printer">
        <!-- 这里把value属性 换成ref 指向文件中配置好的一个纸张类 -->        
        <property name="paper" ref="A5"></property>
    </bean>

这样就可以注入一个复杂类型的属性

二、 核心思想—>AOP(面向切面)

首先你需要导入AOP包,且要修改配置文件(application.xml)的头为:

以logger日志输出为例…..

1、新建日志输出类 LoggerAop

import java.util.Arrays;

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


public class LoggerAop {
    private Logger logger = Logger.getLogger(LoggerAop.class.getName());

    public void before(JoinPoint jp) {
        logger.info("before调用" + jp.getTarget().getClass().getName() + "的"                  +jp.getSignature().getName()+ "方法. 方法入参:" + Arrays.toString(jp.getArgs()));
    }

    public void afterReturning(JoinPoint jp,Object result) {
        logger.info("afterReturning调用" + jp.getTarget().getClass().getName() + "的" + jp.getSignature().getName()
                + "方法. 方法返回值:" + result);
    }


}

2、在配置文件(application.xml)添加 Aop 配置

<!-- 配置增强类 "class"属性对应增强类的地址  -->
<bean id="loggerAop" class="aop.LoggerAop"></bean>


<!-- 配置增强处理 -->
<aop:config>
    <!-- 配置切入点  "expression"配置的是什么包下的什么类什么方法作为切入点-->
    <!-- expression="execution(* com.service.*.*(..)) ----表示com.service包下所有类的所以方法  -->
    <!-- expression="execution(* com.service..*.*(..)) ----表示com.service包及其子包下所有类的所以方法  -->
    <aop:pointcut expression="execution(* inkBox..*.*(..))" id="pointcut" />


    <!-- 引入增强类 -->
    <aop:aspect ref="loggerAop">
          <!-- 配置增强方法  切入点配置增强类的哪个方法-->
          <!-- 前置增强 method表示引用增强类的哪个方法(方法名) -->
          <!-- "pointcut-ref" 引入切入点 -->
          <aop:before method="before" pointcut-ref="pointcut" />          
          <aop:after method="after" pointcut-ref="pointcut"/>        
    </aop:aspect>
</aop:config>

然后你在调用 inkBox包下的所有类的方法时会发生:

AOP(面向切面) 类似之前的过滤器 Filter—->相当于在你配置的切入点之前和之后做些什么事

增强类型:

1、 异常抛出增强

<!-- 发生异常时执行的增强 注意"throwing"指定的参数名称必须和 增强类中的异常参数一致! -->
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>

<!-- 增强类中添加的方法 -->
public void afterThrowing(JoinPoint jp,Exception ex){
        logger.info("afterThrowing"+ jp.getTarget().getClass().getName() + "的" + jp.getSignature().getName()+ex.getMessage());
}

2、 最终增强

<aop:after method="after" pointcut-ref="pointcut"/>
<!-- 特点:无论方法是抛出异常还是正常退出,该增强都会得到执行,一般用于释放资源 -->

3、 环绕增强
在目标方法的前后都可以织入增强处理,在环绕增强处理中,可以获取或修改目标方法的参数、返回值,可以进行异常处理,甚至可以决定目标方法是否被执行.

<!-- 添加环绕增强 -->
<aop:around method="around" pointcut-ref="pointcut"/>

<!-- 增强类添加的方法 -->
public Object around(ProceedingJoinPoint pjp) throws Throwable {
        logger.info("调用" + pjp.getTarget().getClass().getName() + "的" + pjp.getSignature().getName()+"方法入参:"+Arrays.toString(pjp.getArgs()));
        Object obj = null;
        try {
            // 让程序继续执行
            // 此处的obj不接收对afterreturning没有影响
            // 对程序中接受返回值有影响,所以要返回返回值
            obj = pjp.proceed();
            logger.debug(pjp.getTarget().getClass().getName() +"返回值是:" + obj);
            return obj;
        } catch (Throwable e) {
            logger.error(pjp.getTarget().getClass().getName() +"方法发生异常:"+e.getMessage());
            throw e;
        }
        finally{
            logger.info(pjp.getTarget().getClass().getName() +"方法结束");
        }

    }
    <!-- ProceedingJoinPoint  是 JoinPoint的子接口 -->

3、 after-returning增强
用于获得方法的返回值

<!-- returning指向的参数必须和增强方法中的参数一直 -->
<aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>

<!-- 添加增强方法 -->
public void afterReturning(JoinPoint jp,Object result) {
        logger.info("afterReturning调用" + jp.getTarget().getClass().getName() + "的" + jp.getSignature().getName()
                + "方法. 方法返回值:" + result);
    }