IOC和AOP使用拓展 | 易学教程

多种方式实现依赖注入

构造注入

编写测试类

public class UserServiceImpl implements UserService {

    // 声明接口类型的引用,和具体实现类解耦合
    private UserDao dao;

    // 无参构造
    public UserServiceImpl() {
    }

    // 用于为dao属性赋值的构造方法
    public UserServiceImpl(UserDao dao) {
        this.dao = dao;
    }

    public void addNewUser(User user) {
        // 调用用户DAO的方法保存用户信息
        dao.save(user);
    }
}

在使用设值注入时,Spring通过JavaBean无参构造方法实例化对象,当我们编写带参构造方法后,java虚拟机不会再提供默认的无参构造方法,为了保证使用的灵活性,建议自行添加一个无参构造方法
配置文件代码如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd ">
    <!-- 定义UserDaoImpl对象,并指定id为userDao -->
    <bean id="userDao" class="dao.impl.UserDaoImpl" />
    <!-- 定义UserServiceImpl对象,并指定id为userService -->
    <bean id="userService" class="service.impl.UserServiceImpl">
        <!-- 通过定义的单参构造为userService的dao属性赋 值 -->
        <constructor-arg>
            <!-- 引用id为userDao的对象为userService的dao属性赋值 -->
            <ref bean="userDao" />
        </constructor-arg>
    </bean>
</beans>

1 一个 constructor-arg元素表示构造方法的一个参数，且使用时不区分顺序。
2 通过constructor-arg元素的index 属性可以指定该参数的位置索引，位置从0 开始。
3 constructor-arg元素还提供了type 属性用来指定参数的类型，避免字符串和基本数据类型的混淆。

constructor-arg节点下的四个属性

index是索引，指定注入的属性，从0开始，如：0代表personDao，1代表str属性；
type是指该属性所对应的类型，如Persondao对应的是com.aptech.dao.PersonDAO；
ref 是指引用的依赖对象；
value 当注入的不是依赖对象，而是基本数据类型时，就用value；

比如:

<bean id="Rod" class="cn.springdemo.Greeting">
    <constructor-arg index="1">
    <value>Rod</value>
    </constructor-arg>
    <constructor-arg index="0">
    <value>世界上有10种人</value>
    </constructor-arg>
</bean>

使用p命名空间实现属性注入

p命名空间的特点:使用属性而不是子元素的形式配置Bean的属性,从而简化了配置代码
语法:
对于直接量（基本数据类型、字符串）属性：p:属性名="属性值"
对于引用Bean的属性：p:属性名-ref="Bean的id"
使用前先要在Spring配置文件中引入p命名空间

xmlns:p="http://www.springframework.org/schema/p"

示例:

<?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.xsd">
    <!-- 使用p命名空间注入属性值 -->
    <bean id="user" class="entity.User" p:username="皮皮" p:age="21"
        p:email="pipi@anxin.com" />
    <bean id="userDao" class="dao.impl.UserDaoImpl" />
    <bean id="userService" class="service.impl.UserServiceImpl" p:dao-ref="userDao" />
</beans>

注入不同数据类型

注入直接量

使用标签实现
注意特殊字符的处理
示例:

<bean id="user" class="entity.User">
    <property name="username">
        <value>张三</value>
    </property>
    <property name="age">
        <value>23</value>
    </property>
</bean>

如果属性值中包含了XML文件的特殊字符(& < > " '),则注入需要进行处理,通常可以采用两种办法,使用<[CDATA[]]>标记或把特殊字符替换为实体引用.

<bean id="product" class="entity.Product">
         <!-- 使用<![CDATA[]]>标记处理XML特 殊字符 -->
        <property name="specialCharacter1">
            <value><![CDATA[P&G]]></value>
        </property>
        <!-- 把XML特殊字符替换为实体引用 -->
        <property name="specialCharacter2">
            <value>P&amp;G</value>
        </property>
<bean>

符号	实体引用
<	& lt;
>	& gt;
&	& amp;
'	& apos;
"	& quot;

注意:在XML文件中字符"<"和“&”是非法的,其他3个符号是合法的,但是将它们替换为实体引用是个好习惯

引用其他Bean组件

Spring中定义的Bean可以互相引用,从而建立依赖关系,除了使用ref属性,还可以通过子元素实现.
引用其他Bean组件

<bean id="userDao" class="dao.impl.UserDaoImpl"/>
<bean id="userService"  class="service.impl.UserServiceImpl">
    <property name="dao">
        <ref bean="userDao"/>
    </property>
</bean>

使用内部Bean

<!-- 定义内部Bean -->
<bean id="userService" class="service.impl.UserServiceImpl">
    <property name="dao">
        <bean class="dao.impl.UserDaoImpl"/>
    </property>
</bean>

这样这个UserDaoImpl类型的Bean就只能被userUservice使用,其他的Bean则无法使用

注入集合类型的属性

对于List或数组类型的属性,可以使用标签注入

<!-- 注入List类型 -->
<property name="list">
    <list>
        <!-- 定义List中的元素 -->
        <value>足球</value>
        <value>篮球</value>
    </list>
</property>

标签中间可以使用,等标签注入集合元素,也可以是另一个标签
Map类型的属性,使用标签

<!-- 注入Map类型 -->
<property name="map">
    <map>
        <!-- 定义Map中的键值对 -->
        <entry>
            <key>
                <value>football</value>
            </key>
            <value>足球</value>
        </entry>
        <entry>
            <key>
                <value>basketball</value>
            </key>
            <value>篮球</value>
        </entry>
    </map>
</property>

注入null和空字符串值
可以使用注入空字符串,使用注入null值

<!-- 注入空字符串值 -->
<property name="emptyValue">
    <value></value>
</property>
    <!-- 注入null值 -->
<property name="nullValue">
    <null/>
</property>

其他增强类型

Spring支持多种增强类型,除了我们上一篇文章说的前置增强和后置增强,在这里我们在补充几种常用的增强类型

异常抛出增强

异常抛出增强的特点是在目标方法抛出异常时织入增强处理。使用异常抛出增强,可以为各功能模块提供统一的,可拨插的异常处理方案

/**
 * 定义包含增强方法的JavaBean
 */
public class ErrorLogger {
    private static final Logger log = Logger.getLogger(ErrorLogger.class);

    public void afterThrowing(JoinPoint jp, RuntimeException e) {
        log.error(jp.getSignature().getName() + " 方法发生异常：" + e);
    }
}

Spring配置文件

<!-- 声明增强方法所在的Bean -->
<bean id="theLogger" class="aop.ErrorLogger"></bean>
    <!-- 配置切面 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut id="pointcut" expression="execution(* service.UserService.*(..))" />
        <!-- 引用包含增强方法的Bean -->
        <aop:aspect ref="theLogger">
            <!-- 将afterThrowing()方法定义为异常抛出增强并引用pointcut切入点 -->
            <!-- 通过throwing属性指定为名为e的参数注入异常实例 -->
            <aop:after-throwing method="afterThrowing"
                pointcut-ref="pointcut" throwing="e" />
        </aop:aspect>
    </aop:config>
</beans>

expression指示符我们上一篇文章已经说话大家可以先看一下上一篇文章
使用元素可以定义异常抛出增强。如果需要获取抛出的异常,可以为增强方法声明相关类型的参数,并通过元素的throwing的属性指定该参数名称,Spring会为其注入从目标方法抛出的异常实例.

最终增强

最终增强的特点是无论抛出异常还是正常退出,该增强都会得到执行,类似于异常处理机制中finally块的作用,一般用于释放资源,使用最终增强,就可以为各功能模块提供统一的,可拨插的处理方案.

/**
 * 定义包含增强方法的JavaBean
 */
public class AfterLogger {
    private static final Logger log = Logger.getLogger(AfterLogger.class);

    public void afterLogger(JoinPoint jp) {
        log.info(jp.getSignature().getName() + " 方法结束执行。");
    }
}

Spring配置文件

<!-- 声明增强方法所在的Bean -->
    <bean id="theLogger" class="aop.AfterLogger"></bean>
    <!-- 配置切面 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut id="pointcut" expression="execution(* service.UserService.*(..))" />
        <!-- 引用包含增强方法的Bean -->
        <aop:aspect ref="theLogger">
            <!-- 将afterLogger()方法定义为最终增强并引用pointcut切入点 -->
            <aop:after method="afterLogger" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

使用元素即可定义最终增强

环绕增强

环绕增强在目标方法的前后都可以织入增强处理.环绕增强是功能最强大的增强处理,Spring把目标方法的控制权全部交给它,在环绕增强处理中,可以获取或修改目标方法的参数,返回值可以对它进行异常处理,甚至可以决定目标方法是否被执行.

/**
 * 定义包含增强方法的JavaBean
 */
public class AroundLogger {
    private static final Logger log = Logger.getLogger(AroundLogger.class);

    public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {
        log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().getName()
                + " 方法。方法入参：" + Arrays.toString(jp.getArgs()));
        try {
            Object result = jp.proceed();
            log.info("调用 " + jp.getTarget() + " 的 "
                    + jp.getSignature().getName() + " 方法。方法返回值：" + result);
            return result;
        } catch (Throwable e) {
            log.error(jp.getSignature().getName() + " 方法发生异常：" + e);
            throw e;
        } finally {
            log.info(jp.getSignature().getName() + " 方法结束执行。");
        }
    }
}

Spring配置文件

<!-- 声明增强方法所在的Bean -->
<bean id="theLogger" class="aop.AroundLogger"></bean>
    <!-- 配置切面 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut id="pointcut" expression="execution(* service.UserService.*(..))" />
        <!-- 引用包含增强方法的Bean -->
        <aop:aspect ref="theLogger">
            <!-- 将aroundLogger()方法定义为环绕增强并引用pointcut切入点 -->
            <aop:around method="aroundLogger" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

使用元素可以定义环绕增强,通过为增强方法声明ProceedingJoinPoint类型的参数,可以获得连接点信息,所用方法与JoinPoint相同.ProceedingJoinPoint是JoinPoint的子接口,其不但封装目标方法及其入参数组,还封装了被代理的目标对象,通过它的proceed()方法可以调用其真正的目标方法,从而达到对连接点的完全控制
常用的增强处理类型

增强处理类型	特点
Before	前置增强处理，在目标方法前织入增强处理
AfterReturning	后置增强处理，在目标方法正常执行（不出现异常）后织入增强处理
AfterThrowing	异常增强处理，在目标方法抛出异常后织入增强处理
After	最终增强处理，不论方法是否抛出异常，都会在目标方法最后织入增强处理
Around	环绕增强处理，在目标方法的前后都可以织入增强处理

Spring AOP配置元素

AOP配置元素	描述
aop:config	AOP配置的顶层元素，大多数的<aop:*>元素必须包含在元素内
aop:pointcut	定义切点
aop:aspect	定义切点
aop:after	定义最终增强（不管被通知的方法是否执行成功）
aop:after-returning	定义after-returning增强
aop:after-throwing	定义after-throwing增强
aop:around	定义环绕增强
aop:before	定义前置增强
aop:aspectj-autoproxy	启动@AspectJ注解驱动的切面

使用注解实现IOC的配置

前面我们说过用xml的形式配置IOC,那种方式是比较麻烦的,在Spring2.0以后的版本我们就可以使用注解来配置,进一步减少了配置文件的代码
使用注解定义Bean

/**
 * 用户业务类,实现对User功能的业务管理
 */
@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired  // 默认按类型匹配
    @Qualifier("userDao") // 按指定名称匹配
    private UserDao dao;

    // 使用@Autowired直接为属性注入，可以省略setter方法
    /*public void setDao(UserDao dao) {
        this.dao = dao;
    }*/

    public void addNewUser(User user) {
        // 调用用户DAO的方法保存用户信息
        dao.save(user);
    }
}

上面代码我们通过注解定义了一个名为userDao的Bean@Autowired的作用和在xml文件中编写一样的意思
还有非常重要的一点就是我们要在配置文件中加一行代码,让他支持我们的注解

<!--扫描包中注解标注的类-->
<context:component-scan base-package="service,dao"/>
<!--多个包之前用逗号隔开-->

Spring还提供了其他的注解
@Componet:实现Bean组件的定义
@Repository:用于标注DAO类
@Service:用于标注业务类
@Controller:用于标注控制器类
@Autowired:实现Bean的自动装配
@Qualifier:指定Bean的名称
@Resource:实现Bean的组件装配
大家可以查看Spring的开发手册进一步了解他们的用法

使用注解定义切面

AspectJ
面向切面的框架，它扩展了Java语言，定义了AOP 语法，能够在编译期提供代码的织入
@AspectJ
AspectJ 5新增的功能，使用JDK 5.0 注解技术和正规的AspectJ切点表达式语言描述切面
Spring通过集成AspectJ实现了以注解的方式定义增强类，大大减少了配置文件中的工作量
利用轻量级的字节码处理框架asm处理@AspectJ中所描述的方法参数名
使用注解定义切面实现日志功能

/**
 * 使用注解定义切面
 */
@Aspect
public class UserServiceLogger {
    private static final Logger log = Logger.getLogger(UserServiceLogger.class);
    
    @Pointcut("execution(* service.UserService.*(..))")
    public void pointcut() {}

    @Before("pointcut()")
    public void before(JoinPoint jp) {
        log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().getName()
                + " 方法。方法入参：" + Arrays.toString(jp.getArgs()));
    }
    @AfterReturning(pointcut = "pointcut()", returning = "returnValue")
    public void afterReturning(JoinPoint jp, Object returnValue) {
        log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().getName()
                + " 方法。方法返回值：" + returnValue);
    }
}

切入点表达式使用@Pointcut注解来表示,而切入点签名则需要一个普通的方法定义来提供,
如上面代码中的pointcut()方法,作为切入点签名的方法必须返回void类型,切入点定义好后,就可以使用pointcut()签名进行引用
定义完切面后,还需要在Spring配置文件中完成织入工作

 <context:component-scan base-package="service,dao" />
    <bean class="aop.UserServiceLogger"></bean>
    <aop:aspectj-autoproxy />

配置文件中首先要导入aop命名空间,只需要在配置文件中添加元素,
就可以启用对于@AspecJ注解的支持,Spring将自动为匹配的Bean创建代理
为了注册定义好的切面,还要在Spring配置文件中是声明UserServiceLogger的一个示例,如果不需要被其他的Bean引用,可以不指定id属性

使用注解定义其他类型增强

异常抛出增强

/**
 * 通过注解实现异常抛出增强
 */
@Aspect
public class ErrorLogger {
    private static final Logger log = Logger.getLogger(ErrorLogger.class);

    @AfterThrowing(pointcut = "execution(* service.UserService.*(..))", throwing = "e")
    public void afterThrowing(JoinPoint jp, RuntimeException e) {
        log.error(jp.getSignature().getName() + " 方法发生异常：" + e);
    }

}

使用AfterThrowing注解可以定义异常抛出增强,如果需要获取抛出的异常,可以为增强方法声明相关类型的参数,并通过@AfterThrowing注解的throwing属性指定该参数名称,Spring会为其注入从目标方法抛出的异常实例
其他的方法都是大同小异,大家可以自己动手试一试
@Aspect(定义一个切面 )
@Before(前置增强)
@AfterReturning(后置增强)
@Around (环绕增强)
@AfterThrowing(异常抛出增强)
@After(最终增强)

在配置文件中添加元素,启用对于@Aspect注解的支持

写的不好还有不懂的地方,大家可以留言一下我会尽量解决
by安心

来源：https://www.cnblogs.com/anxin0/p/9946835.html

标签

aop

bean

ioc

spring框架

dao