实现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 {

    /**
     * 获取所有的用户对象列表
     * @return
     */
    List 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 implements IUserService {

    @Override
    public List 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