java动态代理和静态代理

1、静态代理

a、定义：就是代理接口实现某种业务

b、优点：可以在之前的业务基础上增加或者不增加业务

c、缺陷：只代理一种类型的业务，如果增加业务方法，则增加了维护的复杂度

具体举例：

/**
 * @author
 * @vision createtime:2016下午3:00:06
 */
package proxy;

/**
 * @author Administrator
 *
 */
public interface Subject {
	public void study();
}

/**
 * @author
 * @vision createtime:2016下午2:59:50
 */
package proxy;

/**
 * @author Administrator
 *
 */
public class Student implements Subject{
	public String name;
	@Override
	public void study() {
		System.out.println(name+"正在学习");
	}

}

/**
 * @author
 * @vision createtime:2016下午3:00:48
 */
package proxy;

/**
 * @author Administrator
 *
 */
public class StaticProxy implements Subject{
	private Subject sub;
	public StaticProxy(Subject sb) {
		this.sub = sb;
	}
	// 让其在此类方法中执行操作流程
	@Override
	public void study() {
		System.out.println("在执行主业务之前要增加的业务");
		sub.study();
		System.out.println("在执行主业务之后要增加的业务");
	}

}

/**
 * @author
 * @vision createtime:2016下午2:59:27
 */
package proxy;

/**
 * @author Administrator
 * 静态代理测试
 */
public class Test {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "薇恩同学";
		// 传入Student对象
		StaticProxy sp = new StaticProxy(stu);
		sp.study();
	}
}

如此这般，打印出来的如下：

在执行主业务之前要增加的业务
薇恩同学正在学习
在执行主业务之后要增加的业务

我们在开发时候可以选择是否需要增加其他业务

2、动态代理

主要是实现InvocationHandler接口

相对于静态代理而言，就可以切换代理类型

（注意：不管是动态代理还是静态代理，代理的对象都是接口）

具体代码：

/**
 * @author
 * @vision createtime:2016下午3:17:15
 */
package dynproxy;

/**
 * @author Administrator
 *
 */
public interface StudentSubject {
	public void study();
}

/**
 * @author
 * @vision createtime:2016下午3:17:06
 */
package dynproxy;

/**
 * @author Administrator
 *
 */
public interface TeachSubject {
	public void teach();
}

/**
 * @author
 * @vision createtime:2016下午3:19:16
 */
package dynproxy;

/**
 * @author Administrator
 *
 */
public class Student implements StudentSubject {

	@Override
	public void study() {
		System.out.println("学生学习");
	}

}

/**
 * @author
 * @vision createtime:2016下午3:19:25
 */
package dynproxy;

/**
 * @author Administrator
 *
 */
public class Teacher implements TeachSubject{
	public String name;
	@Override
	public void teach() {
		System.out.println(name+"正在上课");
	}

}

/**
 * @author
 * @vision createtime:2016下午3:22:11
 */
package dynproxy;

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

/**
 * @author Administrator
 *
 */
public class DynProxy implements InvocationHandler{
	private Object obj;
	public DynProxy(Object obj) {
		this.obj = obj;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("之前要执行的");
		Object object = method.invoke(obj, args);
		System.out.println("之后要执行的");
		return object;
	}
}

/**
 * @author
 * @vision createtime:2016下午3:13:51
 */
package dynproxy;

import java.lang.reflect.Proxy;

/**
 * @author Administrator
 * 动态代理
 */
public class Test {
	public static void main(String[] args) {
		Teacher teach = new Teacher();
		teach.name = "张三";
		// 创建动态代理对象
		DynProxy dp1 = new DynProxy(teach);
		// 用DynProxy加载被代理对象(teach)
		TeachSubject ts = (TeachSubject)Proxy.newProxyInstance(teach.getClass().getClassLoader(), teach.getClass().getInterfaces(), dp1);
		ts.teach();
		
		Student stu = new Student();
		DynProxy dp2 = new DynProxy(stu);
		StudentSubject ss = (StudentSubject)Proxy.newProxyInstance(stu.getClass().getClassLoader(), stu.getClass().getInterfaces(), dp2);
		ss.study();
	}
}

如上这般，打印的就是：

之前要执行的
张三正在上课
之后要执行的
之前要执行的
学生学习
之后要执行的

针对不同业务，可以分场合使用