实现AOP的三种方式(一):

AOP:

Aspect Oriented Programming的缩写，意为：[面向切面编程]，通过[预编译]方式和运行期间动态代理实现程序功能的统一维护的一种技术。
什么是面向切面编程?

image.png

传统的项目中,我们的业务逻辑是自上而下的,在我们的自上而下的逻辑中,会产生一些横切性的问题,比如说我们的日志记录,权限处理,异常验证,还有一些事务等.
这些横切性问题和我们的主业务逻辑没有直接的关系.关注切面执行的时机顺序等称之为界面编程.

image.png

AOP---编程需要实现的目标
Spring AOP--实现目标的手段

今天学习了AOP的三种实现方式

学习AOP之前首先了解IoC(控制反转)和Bean的概念
下面文档搬运自spring的官方文档,浏览器翻译.
原文链接:https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html

IoC也称为依赖注入（DI)
在此过程中，对象仅通过构造函数参数，工厂方法的参数或在构造或从工厂方法返回后在对象实例上设置的属性来定义其依赖项（即，与它们一起使用的其他对象）。然后，容器在创建bean时注入那些依赖项。此过程从根本上讲是通过使用类的直接构造或诸如服务定位器模式之类的机制来控制其依赖项的实例化或位置的bean本身的逆过程（因此称为Control Inversion）。

IoC容器的基础的两个基础包:
在org.springframework.beans org.springframework.context

BeanFactory 提供了一种高级配置机制，能够管理任何类型的对象(任何类都是bean的对象)

ApplicationContext 是BeanFactory的子接口之一。它增加了：

与Spring的AOP功能轻松集成
消息资源处理（用于国际化）
活动发布
应用层特定的上下文，例如WebApplicationContext 用于Web应用程序中的。

简而言之，BeanFactory提供了配置框架和基本功能，并ApplicationContext增加了更多针对企业的功能。该ApplicationContext是对一个完整的超集BeanFactory，并在Spring的IoC容器的描述本章独占使用。有关使用的详细信息BeanFactory，而不是ApplicationContext,看到 [的BeanFactory]

在Spring中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。Bean是由Spring IoC容器实例化，组装和以其他方式管理的对象。否则，bean仅仅是应用程序中许多对象之一。Bean及其之间的依赖关系反映在容器使用的配置元数据中。

实现AOP的第一种方式:
写一个service接口定义四个方法

import java.util.List;

public interface IUserService<T> {

    /**
     * 获取所有的用户对象列表
     * @return
     */
    List<T> getAllUser();

    /**
     * 保存用户
     * @param user
     * @return
     */
    boolean saveUser(T user);

    /**
     * 根据用户uid删除该uid对应的用户信息
     * @param uid
     * @return
     */
    boolean deleteUser(int uid);

    /**
     * 更新指定用户信息
     * @param obj
     * @return
     */
    boolean updateUser(T obj);
}

//接口的实现类
import java.util.ArrayList;
import java.util.List;

public class UserServiceImpl<T> implements IUserService<T> {

    @Override
    public List<T> getAllUser() {
        System.out.println("--------getAllUser----------");
        return new ArrayList<>();
    }

    @Override
    public boolean saveUser(T user) {
        System.out.println("--------saveUser----------");
        return true;
    }

    @Override
    public boolean deleteUser(int uid) {
        System.out.println("--------deleteUser----------");
        return false;
    }

    @Override
    public boolean updateUser(T obj) {
        System.out.println("--------updateUser----------");
        return true;
    }
}

public class MyAspect {

        public void before(){
            System.out.println("********before**********");
        }

        public void after(){
            System.out.println("********after**********");
        }

}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserFactory {

    public static IUserService getUserService(){

        IUserService us = new UserservcieImpl();

        MyAspect ma = new MyAspect();

        /**
         * 
         *  使用Proxy类的静态方法newProxyInstance来实现对于目标对象us的代理
         *  目的是在原本us可以做的事情之前和之后可以做额外的事情
         * 
         */
        IUserService ius = (IUserService) Proxy.newProxyInstance(UserFactory.class.getClassLoader(), us.getClass().getInterfaces(), new InvocationHandler() {

            /**
             * 代理对象调用的回掉方法      
             * @param proxy 代理对象
             * @param method 被代理的方法
             * @param args 被代理方法的参数列表对象
             * @return 每个方法的最终返回值
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                ma.before();              
                Object obj = method.invoke(us, args);
                ma.after();                
                return obj;
            }
        });

        return ius;
    }
}

UserFactory为工厂类
IUserService 为接口 
 UserservcieImpl实现类 定义类增删改查四个方法

测试类

import org.junit.Test;

public class TestAOP01 {


    @Test
    public void test1(){
    IUserService user =  UserFactory.getIUserService();

        System.out.println(user.getAllUsers());
        System.out.println(user.updateUser(new Object()));
        System.out.println(user.deleteUser(1));
        System.out.println(user.saveUser(new Object()));
    }
}

运行结果:

image.png

可以看到每一次调用方法的前后都执行了MyAspect中的方法

第二种方式:

使用Spring中的一个增强类来实现aop方式
1. 创建Enhancer对象
2. 设置增强类Enhancer的superClass
3. 设置Enhancer对象的回调
4. 通过eh对象的create（）方法来得到指定的对象

//工厂类
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class UserFactory {

    /**
     * 使用Spring中的一个增强类来实现aop方式
     *      1.  创建Enhancer对象
     *      2.  设置增强类Enhancer的superClass
     *      3.  设置Enhancer对象的回调
     *      4.  通过eh对象的create（）方法来得到指定的对象
     * @return
     */
    public static IUserService getUserService(){
        //  1.  创建Enhancer对象
        Enhancer eh = new Enhancer();

        //  2.  设置增强类Enhancer的superClass
        eh.setSuperclass(IUserService.class);

        IUserService<Object> us = new UserServiceImpl<>();

        MyAspect ma = new MyAspect();

        //  3.  设置Enhancer对象的回调
        eh.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                ma.before();

                Object obj = method.invoke(us, objects);

                ma.after();

                return obj;
            }
        });

        //  4.  通过eh对象的create（）方法来得到指定的对象
        IUserService<Object> ius = (IUserService<Object>) eh.create();

        return ius;
    }
}

测试类:

import org.junit.Test;

public class TestAOP02 {

    @Test
    public void testAOP02(){
//        IUserService<Object> us = new UserServiceImpl<>();

        Object o = new Object();

//        System.out.println(us.getAllUser());
//        System.out.println(us.saveUser(o));
//        System.out.println(us.deleteUser(1));
//        System.out.println(us.updateUser(o));

        System.out.println("==============");

        IUserService ius = UserFactory.getUserService();

        System.out.println(ius.getAllUser());
        System.out.println(ius.saveUser(o));
        System.out.println(ius.deleteUser(1));
        System.out.println(ius.updateUser(o));
    }
}

第三种方式:
使用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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="us" class="com.qfedu.aop03.UserServiceImpl" />
    <bean id="my" class="com.qfedu.aop03.MyAspect" />

    <!--
        ProxyFactoryBean代理的FactoryBean对象，我们现在要代理的是us
            包含四个属性注入：
                1.  interfaces: 接口对象们
                    <list>
                        <value>com.qfedu.aop03.IUserService</value>
                        <value>com.qfedu.aop03.IUserService</value>
                        <value>com.qfedu.aop03.IUserService</value>
                    </list>
                2.  target:目标对象，哪个对象将被以代理的方式创建
                3.  interceptorNames:拦截对象的名称，自定义的MethodInterceptor对象，注意它的包结构组成
                4.  optimize:boolean类型的值：
                        true：强制使用cglib的动态代理方式
                        false：使用jdk自带的动态代理

                        cglib：code generation library，代码生成库，性能更高

    -->
    <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="com.qfedu.aop03.IUserService" />
        <property name="target" ref="us" />
        <property name="interceptorNames" value="my" />
        <property name="optimize" value="true" />
    </bean>
</beans>

MyAspect类

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

public class MyAspect implements MethodInterceptor {

    private void before(){

        System.out.println("---------before----------");

    }

    private void after(){

        System.out.println("---------after----------");

    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {

        before();

        //  业务处理方法的调用
        Object obj = invocation.proceed();

        after();

        return obj;
    }
}

测试类:

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

public class TestAOP03 {

    @Test
    public void testAOP03(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/qfedu/aop03/beans.xml");

        IUserService us = ac.getBean("proxy", IUserService.class);

        Object o = new Object();

        System.out.println(us.getAllUser());
        System.out.println(us.deleteUser(1));
        System.out.println(us.saveUser(o));
        System.out.println(us.updateUser(o));
    }
}

AOP两种代理的区别：

AOP支持2种代理，jdk的动态代理和cglib实现机制。

jdk基于接口实现：jdk动态代理对实现了接口的类进行代理。

cglib基于继承：cglib代理可以对类代理，主要对指定的类生成一个子类，因为是继承，所以目标类最好不要使用final声明。

通常情况下，鼓励使用jdk代理，因为业务一般都会抽象出一个接口，而且不用引入新的东西。如果是遗留的系统，以前没有实现接口，那么只能使用CGLIB。