具体思想是：定义一个切面，在切面的纵向定义处理方法，处理完成之后，回到横向业务流。
1.静态代理：设计模式中的proxy模式
a.业务接口
//抽象主题角色:声明真实主题和代理主题的共同接口
public interface ITalk { public void talk(String msg); }
b.业务实现
//真实主角色:定义真实的对象
public class PeopleTalk implements ITalk {
public String username;
public String age;
public PeopleTalk(String username, String age){
this.username = username;
this.age = age;
}
public void talk(String msg){
System.out.println(msg + "!你好,我是" + username + "，我年龄是" + age);
}
public String getName(){
return username;
}
public void setName(String name){
this.username = name;
}
public String getAge(){
return age;
}
public void setAge(String age){
this.age = age;
}
}
c.代理对象
//代理主题角色:内部包含对真实主题的引用，并且提供和真实主题角色相同的接口
public class TalkProxy implements ITalk {
private ITalk talker;
public TalkProxy(ITalk talker) {
// super();
this.talker = talker;
}
public void talk(String msg) {
talker.talk(msg);
}
public void talk(String msg, String singname) {
talker.talk(msg);
sing(singname);
}
private void sing(String singname) {
System.out.println("唱歌：" + singname);
}
}
d.测试类
//代理测试类，使用代理
public class ProxyPattern {
public static void main(String[] args) {
// 不需要执行额外方法的。
ITalk people = new PeopleTalk("AOP", "18");
people.talk("No ProXY Test");
System.out.println("-----------------------------");
// 需要执行额外方法的（切面）
TalkProxy talker = new TalkProxy(people);
talker.talk("ProXY Test", "代理");
}
}
上端代码中talk(String msg, String singname)是一个切面。在代理类中的sing(singname)方法是个后置处理方法。
这样就实现了，其他的辅助方法和业务方法的解耦。业务不需要专门去调用，而是走到talk方法，顺理成章的调用sing方法
再从这段代码看：1、要实现代理方式，必须要定义接口。2、每个业务类，需要一个代理类。
2、动态代理：jdk1.5中提供，利用反射。实现InvocationHandler接口。
a.代理类:
public class DynamicProxy implements InvocationHandler {
/** 需要代理的目标类 */
private Object target;
/** * 写法固定，aop专用:绑定委托对象并返回一个代理类
*
* @param delegate
* @return
*/
public Object bind(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
/** * @param Object
* target：指被代理的对象。
* @param Method
* method：要调用的方法
* @param Object
* [] args：方法调用时所需要的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
// 切面之前执行
System.out.println("切面之前执行");
// 执行业务
result = method.invoke(target, args);
// 切面之后执行
System.out.println("切面之后执行");
return result;
}
}
b.测试类:
public class Test {
public static void main(String[] args) {
// 绑定代理，这种方式会在所有的方法都加上切面方法
ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk());
iTalk.talk("业务说明");
}
}
输出结果是:
切面之前执行
people talk业务说法
切面之后执行
3.利用cglib
CGLIB是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强。采用的是继承的方式。
a.业务类
public class PeopleTalk {
public void talk(String msg) {
System.out.println("people talk" + msg);
}
}
b.cglib代理类:
public class CglibProxy implements MethodInterceptor {
private Object target;
/**
* 创建代理对象
*
* @param target
* @return
*/
public Object getInstance(Object target){
this.target = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object result = null;
System.out.println("事物开始");
result = methodProxy.invokeSuper(proxy, args);
System.out.println("事物结束");
return result;
}
}
c.测试类
public class Test{
public static void main(String[] args){
PeopleTalk peopleTalk = (PeopleTalk) new CglibProxy().getInstance(new PeopleTalk());
peopleTalk.talk("业务方法");
peopleTalk.spreak("业务方法");
}
}
最后输出的结果:
事物开始
people talk业务方法
事物结束
事物开始
spreak chinese业务方法
事物结束