实现AOP的几种方式

AOP是一种编程思想，是OOP编程思想的补充。AOP的实现有很多种，下面简单介绍几种。

测试AOP需要的一些基础类

Font.java

package com.java.proxy;

import lombok.Data;

@Data
public class Font {

	private String name;
}

FontProvider.java

package com.java.proxy;


public interface FontProvider {
	
	Font getFont(String name);
	
	void printName(String name);
}

FontProviderFromDisk.java

package com.java.proxy;

public class FontProviderFromDisk implements FontProvider {

	
	@Override
	public Font getFont(String name) {
		Font font = new Font();
		font.setName(name);
		return font;
	}

	@Override
	public void printName(String name) {
		System.out.println(name);
		
	}

}

ProviderFactory.java

package com.java.proxy;

public abstract class ProviderFactory {

	
	public static FontProvider getFontProvider() {
        return new FontProviderFromDisk();
    }
}

Bussiness.java

package com.java.proxy;

public class Business {

	public static void main(String[] args) {
		 FontProvider fontProvider = ProviderFactory.getFontProvider();
	        Font font = fontProvider.getFont("微软雅黑");
	        System.out.println(font);
	}

}

执行Bussiness代码的结果：

上面实现的功能就是，通过工厂获取FontProvider，通过Provider获取Font，最后调用功能（这里只是简单的输出）。

下面我们要在getFont()前后加些功能，达到aop的效果。直接修改以前的FontProviderFromDisk类，违反了开闭原则，是不好的，如果有很多FontProvider的实现，需要一一修改，容易出错。

1、代理模式静态的实现AOP

为了编码的规范，遵守一些编程原则，我们使用代理模式，增加一个具有缓存功能的代理类。

代理类CachedFontProvider.java

package com.java.proxy.staticporxy;

import java.util.HashMap;
import java.util.Map;

import com.java.proxy.Font;
import com.java.proxy.FontProvider;
import com.java.proxy.FontProviderFromDisk;

/**
 * 给FontProvider的getFont添加缓存功能，用静态代理来实现
 * @author 
 *
 */
public class CachedFontProvider implements FontProvider {

	private FontProvider fontProvider;
	
	private Map<String, Font> cached = new HashMap<String, Font>();
	
	
	public CachedFontProvider() {
		fontProvider = new FontProviderFromDisk();
	}



	@Override
	public Font getFont(String name) {
		System.out.println("静态代理getFont()");
		Font font = cached.get(name);
		if(font == null) {
			font = fontProvider.getFont(name);
			cached.put(name, font);
		}
		return font;
	}



	@Override
	public void printName(String name) {
		System.out.println("静态代理printName()");
		fontProvider.printName(name);;
		
	}

	
}

工厂类也需要做一些改变ProviderFactory.java

/**
 * 每个字体都增加了缓存功能，其实工厂就是用的缓存字体提供器，跟io一样
 * 使用代理（静态），已经避免了再去修改每个字体提供器（这违反了开闭原则，而且工作量很大，容易出错；而且如果要增加别的功能
 * 比如日志打印，权限检查，异常处理，每个都要去修改，代码重复，而且很麻烦）
 * 
 * ② 然而为什么要用动态代理？
 *考虑以下各种情况，有多个提供类，每个类都有getXxx(String name)方法，
 *每个类都要加入缓存功能，使用静态代理虽然也能实现，但是也是略显繁琐，需要手动一一创建代理类。
 * @author wb-yb197819
 *
 */
public class ProviderFactory {

	public static FontProvider getFontProvider() {
		return new CachedFontProvider();
	}
	
	
	
}

测试类Bussiness.java

package com.java.proxy.staticporxy;

import com.java.proxy.Font;
import com.java.proxy.FontProvider;

public class Business {

	public static void main(String[] args) {
		 FontProvider fontProvider = ProviderFactory.getFontProvider();
	        Font font = fontProvider.getFont("微软雅黑");
	        System.out.println(font);
	        fontProvider.printName("代理模式实现AOP");
	}

}

执行结果：

说明:我们通过工厂获取provider的某个功能代理对象，在调用getFont(),在代理的对象方法中添加功能，调用被代理的功能，实现AOP效果。

2、aspectj静态代理实现AOP

利用aspectj实现AOP功能，需要安装eclipse的aspectj插件（编译*.aj文件，jdk编译不了*.aj文件），依赖aspectj的jar包。

具体操作参考：在maven项目中使用aspectj

Hello.java

package com.java.proxy.aspectj;

public class Hello {
	public void hello(String name) {
        System.out.println(name+",hello!");
    }
}

HelloWorld.aj

package com.java.proxy.aspectj;

public aspect HelloWorld {
	/**
     * 第一个*号是指返回值不限，第二个*号是指方法名不限
     * 括号只是任意个数类型不限的形参
     */
	before() : call(* com.java.proxy.aspectj.*.*(..)) {
        System.out.println("hello前的检查,哈哈");
    }
    after() : call(* com.java.proxy.aspectj.*.*(..)) {
        System.out.println("hello后的检查，哈哈");
    }
}

测试类

package com.java.proxy.aspectj;

public class Test {

	public static void main(String[] args) {
		Hello hello = new Hello();
        hello.hello("张三");
	}

}

执行结果：

说明：aspectj帮我们将功能，在编译的阶段将织入到被代理的class文件里面。因为是静态织入，所以性能比较不错。平时很少用到，如果工作中需要使用aspectj，那就要全面掌握aspectj，aspectj官网：https://www.eclipse.org/aspectj/

3、jdk动态代理实现AOP

CachedProviderHandler.java

package com.java.proxy.dynamicporxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class CachedProviderHandler implements InvocationHandler{
	
	private Map<String, Object> cached = new HashMap<String, Object>();
	private Object target;
	
	public CachedProviderHandler(Object target) {
		this.target = target;
	}

	/**
	 * invoke方法可以处理target的所有方法，这里用if判断只处理了getXXX()方法，增加了缓存功能。
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("使用动态代理了！");
		Class<?>[] types = method.getParameterTypes();
		if(method.getName().matches("get.+") && types.length == 1 && types[0] == String.class) {
			System.out.println("getXXX()方法，使用缓存");
			String key = (String)args[0];
			Object value = cached.get(key);
			if(value == null) {
				value = method.invoke(target, args);
				cached.put(key, value);
			}
			return value;
		}
		return method.invoke(target, args);
	}

}

工厂类ProviderFactory.java

package com.java.proxy.dynamicporxy;

import java.lang.reflect.Proxy;

import com.java.proxy.FontProvider;
import com.java.proxy.FontProviderFromDisk;

public class ProviderFactory {

	public static FontProvider getFontProvider() {
		Class<FontProvider> targetClass = FontProvider.class;
		return (FontProvider)Proxy.newProxyInstance(targetClass.getClassLoader(), new Class[]{targetClass},
				new CachedProviderHandler(new FontProviderFromDisk()));
		
	}
}

测试类

package com.java.proxy.dynamicporxy;

import com.java.proxy.Font;
import com.java.proxy.FontProvider;

public class Business {

	public static void main(String[] args) {
		FontProvider fontProvider = ProviderFactory.getFontProvider();
		Font font = fontProvider.getFont("微软雅黑");
		System.out.println(font);
		fontProvider.printName("sdfdf");
	}

}

执行结果：

说明：jdk动态代理需要用Proxy.newProxyInstance来生成代理对象，这里有依赖被代理对象的接口，如果没有接口的就不行。

一句话：jdk动态代理比较好用，就是获取代理对象稍显麻烦。

4、cglib动态代理实现AOP

CGLibProxy.java

package com.java.proxy.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGLibProxy implements MethodInterceptor{
	
	@SuppressWarnings("unchecked")
	public <T> T getProxy(Class<T> cls) {
		return (T) Enhancer.create(cls, this);
		
	}

	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		System.out.println("使用cglib1");
		Object result = proxy.invokeSuper(obj, args);
		System.out.println("使用cglib2");
		return result;
	}

}

测试类

package com.java.proxy.cglib;

import com.java.proxy.FontProviderFromDisk;

public class Business {

	public static void main(String[] args) {
		CGLibProxy cgLibProxy = new CGLibProxy();
		FontProviderFromDisk proxy = cgLibProxy.getProxy(FontProviderFromDisk.class);
		proxy.printName("微软雅黑");
	}

}

执行结果：

说明：cglib较前面提到的这几种实现AOP功能，是最好用的。用Enhancer.create(Class, this)获取代理对象更方便，不依赖于接口，代理功能实现起来更简单。

先写到这里，后面在完善。

实现AOP的几种方式

猜你喜欢