学习spring前，先了解了解代理模式
什么是代理模式
举个例子，我是一个包租公，我现在想卖房，但是我不想麻烦，每天被电话骚扰，所以这个时候我找了楼下一个中介，让他帮我代理这些事，那么他自然有租房的方法。以后如果有人想租房，直接找中介就行了。
public interface Sale {
public void sale();
}
public class Jiajun implements Sale{
public void sale() {
// TODO 自动生成的方法存根
System.out.println("jiajun要卖房");
}
}
public class SaleProxy implements Sale{
Jiajun jiajun=new Jiajun();
@Override
public void sale() {
// TODO 自动生成的方法存根
jiajun.sale();
}
}
public Client{
public static void main(String[] args)
{
Sale saleProxy=new SaleProxy();
saleProxy.sale();
}
}
为什么用代理模式
从上面的代码可以看出，代理类（SaleProxy）和真实类（Jiajun）好像没什么区别，我直接（new Jiajun().sale()）不就行了，那么为什么多次一举呢，任何设计都有他的好处。我们可以发现代理类可以在真实类的基础上增加方法，比如这个时候中介可以收取买主的费用。
public class SaleProxy implements Sale{
Jiajun jiajun=new Jiajun();
@Override
public void sale() {
// TODO 自动生成的方法存根
charge();
jiajun.sale();
}
public void charge()
{
System.out.println("jiajun要卖房,中介要收费");
}
}
而这个不关我事，中介你帮我租出去就行。
什么是动态代理模式
静态代理模式有他的缺点：
- 如果这个时候，我要做的事情增多了，比如我在卖房的时候，我还可以租房。那么我在Sale接口要增加一个方法，真实类（Jiajun）要实现多一个方法，此时代理类（SaleProxy）又要实现多一个方法，如果以后要拓展，会增加很多方法，那么就增加维护难度。
public interface Sale {
public void sale();
public void rent();
}
public class SaleProxy implements Sale{
Jiajun jiajun=new Jiajun();
@Override
public void sale() {
// TODO 自动生成的方法存根
jiajun.sale();
}
public void rent()
{
jiajun.rent();
}
}
- 如果真实类（Jiajun）实现了多个接口,我要为多种方法代理，那么我要手动创建很多代理类。
比如这里我实现了两个接口。
public interface Sale {
public void sale();
}
public interface Buy {
public void buy();
}
public class Jiajun implements Sale,Buy{
public void sale() {
// TODO 自动生成的方法存根
System.out.println("jiajun要卖房");
}
public void buy() {
// TODO 自动生成的方法存根
System.out.println("jiajun要买房");
}
}
这个时候我要生成两个代理，那么我就要创建两个代理类
public class BuyProxy implements Buy{
Jiajun jiajun=new Jiajun();
public void buy() {
// TODO 自动生成的方法存根
jiajun.buy();
}
}
public class SaleProxy implements Sale{
Jiajun jiajun=new Jiajun();
@Override
public void sale() {
// TODO 自动生成的方法存根
jiajun.sale();
}
}
public class Client {
public static void main(String[] args) {
Sale saleProxy=new SaleProxy();
saleProxy.sale();
Buy buyProxy=new BuyProxy();
buyProxy.buy();
}
}
如果我要为多种方法代理,那么就会产生很多代理类。
针对这些缺点，动态代理出现了
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyHandler implements InvocationHandler{
private Object tar;
//绑定委托对象，并返回代理类
public Object bind(Object tar)
{
this.tar=tar;
//绑定该类实现的所有接口，取得代理类
return Proxy.newProxyInstance(tar.getClass().getClassLoader(), tar.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy , Method method , Object[] args)throws Throwable
{
Object result = null;
result = method.invoke(tar,args);
return result;
}
}
public class Client {
public static void main(String[] args) {
ProxyHandler proxy = new ProxyHandler();
//绑定该类实现的所有接口
Sale saleProxy = (Sale) proxy.bind(new Jiajun());
saleProxy.sale();;
Buy buyProxy=(Buy)proxy.bind(new Jiajun());
buyProxy.buy();
}
}
显然，上面的缺点得到解决了。
- 即使接口增加方法，我也不用在代理类再实现一次。
- 即使我要对不同方法做代理，我也不用创建一个代理类文件。
- 动态代理类由Java反射机制动态生成，不用我们自己生成（这里我们并没有看到买房代理类，卖房代理类文件）
- 动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。（我们要买房代理就买房代理，卖房代理就卖房代理，比较灵活）。
- 总的来说，关键的就是我们避免了代理类文件的编写，从而提高了许多便利。
-
