JAVA-代理

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法

java中的代理模式：
*定义：给目标对象提供一个代理对象，并且由代理对象控制对目标对象的引用
*目的：①：通过代理对象的方式间接的访问目标对象，防止直接访问目标对象给系统带来不必要的复杂性
②：通过代理业务对原有业务进行增强
java当中有三种方式来创建代理对象：静态代理，基于jdk(接口)的动态代理，基于CGLLIB（父类）的动态代理。
相关概念：
目标类：原对象，我们需要代理对象控制他的访问，拓展其功能。
代理类：代理模式产生的对象，是原对象“替身”,已经在原有基础上修改逻辑

                                                     静态代理：

编写代理类：实现目标的接口或者直接继承目标类，完成逻辑的修改
接口实现方式：

关于接口的方式，我们在实现接口的时候，目标类和代理类都必须实现目标接口当中所实现的方法，从某种意义上代理类就可以帮我们实现目标类当中的方法，并且代理类还可以有自己的扩展方法。

举例子：1

最开始我们想买东西就必须代购，因为只有代购员才知道真实的工厂在哪里

代码实现：
首先定义接口------相当于工厂地址和功能
public interface ByClothes {
void clothes(String size);
}

定义目标对象—制造衣服的工厂
public class ClothesFactory implements ByClothes {
@Override
public void clothes(String size) {
System.out.println(“已经为您制作好了一整套size为”+size+“的衣服。。。。。。。。”);
}
}

制造代理对象-------代购
public class proxy implements ByClothes {

//被包含的真是对象
public ClothesFactory factory;

public proxy(ClothesFactory factory) {
	// TODO Auto-generated constructor stub
	this.factory = factory;
}

@Override
public void clothes(String size) {
	FrontService();
	factory.clothes(size);
	endService();
	
}

//前置服务
public void FrontService() {
	System.out.println("根据您的需求进行市场调研");
}

//前置服务
public void endService() {
	System.out.println("为您提供一条龙的包办服务");
}

}

制造测试类------买衣服的人
public class Test {
public static void main(String[] args) {
ClothesFactory clothesFactory = new ClothesFactory();
proxy proxy = new proxy(clothesFactory);
proxy.clothes(“XXl”);
}
}

真实静态代理

细节：我们的目标对象必须实现我们的接口，同时代理对象也必须实现这一接口

静态代理存在哪些问题？
违反了开闭原则：
程序对访问开放，对修改关闭，换句话来说，当需求发生变化时，我们可以增加新模块来解决新需求，而不是通过改变原来的代码来解决我们的新需求

                                                           动态代理

举例子：2
当发现这是一个商机的时候，聚拢身边的朋友成立公司
公司的优势：可以代购很多种商品，不是定性的代购
java实现：
1.新建接口
public interface ByShoot {
void byShoot(String size);
}

2.新建工厂
public class ShootFactory implements ByShoot{

@Override
public void byShoot(String size) {
	System.out.println("已经为您生产出了尺码为"+size+"的鞋子");
}

}
3.新建海外代购公司
public class LisiFactory implements InvocationHandler {

// 被代理的对象
private Object factory ;

public Object getFactory() {
	return factory;
}

public void setFactory(Object factory) {
	this.factory = factory;
}

//ssm: Spring SpringMVC mybitys
//Spring:AOP IOC +....
//AOP:代理    (面向切面的编程)
// 通过代理对象对方法进行增强
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	FrontService();
	Object retObject = method.invoke(factory, args);  //这里用了反射的思想，因为我们不知道调用的是那个工厂的那个方法
	endService();
	return null;
}

// 前置服务
public void FrontService() {
	System.out.println("根据您的需求进行市场调研");
}

// 后置服务
public void endService() {
	System.out.println("为您提供一条龙的包办服务");
}

//调度员工
/**
* 1 新建一名员工
 * 2.告诉员工工厂地址
 * this:绑定
 * @return
 */
public Object getProxyInstance() {
	// TODO Auto-generated method stub
	return Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), this);
}

}

4.新建测试类—买东西的人
public class Test {
public static void main(String[] args) {
ClothesFactory clothesFactory = new ClothesFactory();
ShootFactory shootFactory = new ShootFactory();
LisiFactory lisiFactory = new LisiFactory();
lisiFactory.setFactory(shootFactory);
ByShoot yuangong1 = (ByShoot) lisiFactory.getProxyInstance();
yuangong1.byShoot(“42”);
lisiFactory.setFactory(clothesFactory);
ByClothes yuangong = (ByClothes) lisiFactory.getProxyInstance();
yuangong.clothes(“XXL”);
}
}