spring学习--------AOP的实现

AOP
AOP：aspect oriented programming，翻译过来为“面向切面编程”。
spring AOP就是将一些公共的功能，比如日志，安全等和业务代码结合，当执行业务代码时，把公共代码嵌入到其中。实现公共代码的可重复利用，使得我们的业务代码更加纯粹，我们便可以只专注于业务代码。AOP的本质是动态代理模式。

AOP的实现方式一：通过springAPI来实现
springAPI中实现接口MethodBeforeAdvice该拦截器会在调用方法前执行；实现接口AfterReturningAdvice该拦截器会在调用方法后执行；实现接口MethodInterceptor该拦截器会在调用方法前后都执行，实现环绕结果。

public interface UserService {
	public void add();
	public void update();
	public void delete();
	public void search();
}

public class UserServiceImpl implements UserService {
	@Override
	public void add() {
		System.out.println("增加用户");
	}
	@Override
	public void update() {
		System.out.println("修改用户信息");
	}
	@Override
	public void delete() {
		System.out.println("删除用户信息");
	}
	@Override
	public void search() {
		System.out.println("查询用户信息");
	}
}

public class Log implements MethodBeforeAdvice{
    public void log(){
        System.out.println("进入执行方法");
    }

    /**
     * @param method 被调用的方法对象
     * @param args 被调用的方法的参数
     * @param target 被调用的方法的目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被执行");
    }
}

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.delete();
    }
}

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

        <bean id="userService" class="cn.sxt.service.impl.UserServiceImpl"></bean>
        <bean id="log" class="cn.sxt.log.Log"></bean>
        <aop:config>
            <!-- pointcut切入点  expression表达式-->
            <aop:pointcut expression="execution(* cn.sxt.service.impl.*.*(..))" id="pointcut"></aop:pointcut>
            <!-- 指出需要使用哪些公共的业务 -->
            <aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor>
        </aop:config>

</beans>

项目目录结构如下：

执行结果如下：

AOP的实现方式二：自定义类来实现
将上面的Log类和配置文件做修改，主要是修改配置文件，代码如下。

public class Log{
    public void before(){
        System.out.println("方法执行前");
    }
    public void after(){
        System.out.println("方法执行后");
    }
}

<?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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="userService" class="cn.sxt.service.impl.UserServiceImpl"></bean>
    <bean id="log" class="cn.sxt.log.Log"></bean>
    <aop:config>
        <!-- 配置信息如下 -->
        <aop:aspect ref="log">
            <aop:pointcut expression="execution(* cn.sxt.service.impl.*.*(..))" id="pointcut"></aop:pointcut>
            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
            <aop:after method="after" pointcut-ref="pointcut"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

执行结果如下所示：

AOP的实现方式三：使用注解来实现
还可以使用注解来实现AOP，我们修改Log类和beans.xml配置文件，在Log类前加上@Aspect的注解，在方法前加上@Before和@After的注解，我们再新增一个方法，实现一下环绕方法。beans.xml配置文件也不需要</aop:config>的配置，添加aop:aspectj-autoproxy/即可，aop:aspectj-autoproxy/声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。如下所示：

@Aspect
public class Log{
    @Before("execution(* cn.sxt.service.impl.*.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }
    @After("execution(* cn.sxt.service.impl.*.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }
    @Around("execution(* cn.sxt.service.impl.*.*(..))")
    public Object aroud(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");
        System.out.println("签名："+jp.getSignature());
        //执行目标方法
        Object result =  jp.proceed();
        System.out.println("环绕后");
        return result;
    }
}

<?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.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="cn.sxt.service.impl.UserServiceImpl"></bean>
    <bean id="log" class="cn.sxt.log.Log"></bean>

    <aop:aspectj-autoproxy/>

</beans>

执行结果如下：

由执行结果我们可以看出，环绕方法在方法执行前执行，执行目标方法后执行环绕后，最后执行After。其中jp.getSignature()为方法签名。

以上为【2天学会spring框架-邹波】视频中部分内容加自己整理的一些内容，侵删。