手动实现Spring Aop

最新推荐文章于 2024-08-29 23:25:17 发布

原创最新推荐文章于 2024-08-29 23:25:17 发布 · 3.4k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #aop #框架 #java

Spring 专栏收录该内容

6 篇文章

订阅专栏

本文介绍面向切面编程(AOP)的概念及其在Spring框架中的应用。通过具体实例展示了如何使用AOP分离关注点，降低业务逻辑间的耦合度，并提供了一套完整的AOP实现方案，包括Advice接口及其实现类、目标接口与实现类、BeanFactory、ProxyFactoryBean的编写过程。

Aop，百度百科的解释：在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

到底什么是Aop呢？下面来实现一个：

1、Advice接口，Advice实现类

public interface Advice {

    public void beforeMethod();

    public void afterMethod();
}

public class MyAdvice implements Advice{

    @Override
    public void beforeMethod() {
        System.out.println("beforeMethod!!!");
    }

    @Override
    public void afterMethod() {
        System.out.println("afterMethod!!!");
    }
}

2、目标接口，目标实现类

public interface MyObjectInterface {

    public void print();
}

public class MyObject implements MyObjectInterface {

    @Override
    public void print() {
        System.out.println("这是MyObject类！！");
    }
}

3、编写BeanFactory

public class BeanFactory {

    Properties prop = new Properties();

    /**
     * 构造方法，传入InputStream
     * 
     * @param ips
     */
    public BeanFactory(InputStream ips){
        try {
            prop.load(ips);
        } catch (IOException e) {
            e.printStackTrace();
        };
    }

    public Object getBean(String name){
        String className = prop.getProperty(name);
        Object bean = null;
        try {
            Class clazz = Class.forName(className);
            bean = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (bean instanceof ProxyFactoryBean) {
            Object proxy = null;
            try {
                ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
                Advice advice = (Advice)Class.forName(prop.getProperty("advice")).newInstance();
                Object target = Class.forName(prop.getProperty("target")).newInstance();
                proxyFactoryBean.setAdvice(advice);
                proxyFactoryBean.setTarget(target);
                proxy = proxyFactoryBean.getProxy();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return proxy;
        }
        return bean;
    }
}

4、编写ProxyFactoryBean

public class ProxyFactoryBean {

    private Advice advice;

    private Object target;

    public Advice getAdvice() {
        return advice;
    }

    public void setAdvice(Advice advice) {
        this.advice = advice;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        Object proxy = Proxy.newProxyInstance(
                target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), 
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        advice.beforeMethod();
                        Object reVal = method.invoke(target, args);
                        advice.afterMethod();
                        return reVal;
                    }
                });
        return proxy;
    }
}

5、测试类：

public class AopTest {

    public static void main(String[] args) {
        InputStream ips = AopTest.class.getResourceAsStream("conf.properties");
        Object bean = new BeanFactory(ips).getBean("aop");
        System.out.println(bean.getClass().getName());
        ((MyObjectInterface)bean).print();
    }
}

6、配置文件conf.properties：

#aop=java.util.ArrayList
aop=aop_impl.ProxyFactoryBean
advice=aop_impl.MyAdvice
target=aop_impl.MyObject

7、运行结果：
这里写图片描述